@solidstarters/solid-core 1.2.124 → 1.2.127

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

@@ -1,5 +1,4 @@
 import { Logger, OnModuleInit } from '@nestjs/common';
-import * as amqp from 'amqplib';
 import { QueuesModuleOptions } from "../../interfaces";
 import { QueueMessage, QueueSubscriber } from '../../interfaces/mq';
 import { MqMessageQueueService } from '../mq-message-queue.service';
@@ -92,7 +91,7 @@ export abstract class DatabaseSubscriber<T> implements OnModuleInit, QueueSubscr
             // start the loop
             poll();
 
-            this.logger.debug(`DatabaseSubscriber ready to consume messages: ${JSON.stringify(this.options())}`);
+            this.logger.log(`DatabaseSubscriber ready to consume messages: ${JSON.stringify(this.options())}`);
         }
     }
 

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

@@ -0,0 +1,41 @@
+import { Logger } from '@nestjs/common';
+import { Injectable } from '@nestjs/common';
+
+import { QueueMessage, QueuePublisher } from 'src/interfaces/mq';
+import { classify } from '@angular-devkit/core/src/utils/strings';
+import { SolidIntrospectService } from '../solid-introspect.service';
+
+
+@Injectable()
+export class PublisherFactory<T> {
+    private readonly logger = new Logger(PublisherFactory.name);
+
+    constructor(
+        private readonly solidIntrospectionService: SolidIntrospectService
+    ) {
+    }
+
+    async publish(message: QueueMessage<T>, publisherName: string, brokerToUse?: string): Promise<string> {
+        let defaultBrokerToUse = brokerToUse || process.env.QUEUES_DEFAULT_BROKER;
+        let resolvedPublisherName = `${publisherName}${classify(defaultBrokerToUse)}`;
+
+        // Register all ISolidDatabaseModules implementations
+        let actualPublisherToUse = this.solidIntrospectionService.getProvider(resolvedPublisherName);
+        if (!actualPublisherToUse) {
+
+            // Extra check in place to make sure we do not have to refactor old publishers which have been created earlier. 
+            if (defaultBrokerToUse === 'rabbitmq') {
+                actualPublisherToUse = this.solidIntrospectionService.getProvider(publisherName);
+                if (!actualPublisherToUse) {
+                    throw new Error(`Unable to locate publisher with name ${resolvedPublisherName}`);
+                }
+            }
+        }
+
+        // type safe
+        const typedActualPublisher: QueuePublisher<T> = actualPublisherToUse.instance;
+        this.logger.error(`Resolved publisher with name ${actualPublisherToUse.name}, and with options ${typedActualPublisher.options()}`);
+
+        return typedActualPublisher.publish(message);
+    }
+}

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

@@ -121,7 +121,7 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
                 {},
             );
 
-            this.logger.debug(`RabbitMqSubscriber ready to consume messages: ${JSON.stringify(this.options())} and url: ${this.url}`);
+            this.logger.log(`RabbitMqSubscriber ready to consume messages: ${JSON.stringify(this.options())} and url: ${this.url}`);
         }
     }
 

package/src/services/scheduled-job.service.ts

@@ -0,0 +1,34 @@
+import { Injectable } from '@nestjs/common';
+import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
+import { DiscoveryService, ModuleRef } from "@nestjs/core";
+import { EntityManager, Repository } from 'typeorm';
+import { ScheduledJob } from 'src/entities/scheduled-job.entity';
+import { ModelMetadataService } from './model-metadata.service';
+import { ModuleMetadataService } from './module-metadata.service';
+import { ConfigService } from '@nestjs/config';
+import { FileService } from './file.service';
+import { CrudHelperService } from './crud-helper.service';
+import { CRUDService } from './crud.service';
+import { Logger } from '@nestjs/common';
+
+@Injectable()
+export class ScheduledJobService extends CRUDService<ScheduledJob> {
+  private readonly logger = new Logger(ScheduledJobService.name);
+
+  constructor(
+    readonly modelMetadataService: ModelMetadataService,
+    readonly moduleMetadataService: ModuleMetadataService,
+    readonly configService: ConfigService,
+    readonly fileService: FileService,
+    readonly discoveryService: DiscoveryService,
+    readonly crudHelperService: CrudHelperService,
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    @InjectRepository(ScheduledJob)
+    readonly repo: Repository<ScheduledJob>,
+    readonly moduleRef: ModuleRef
+
+  ) {
+    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'scheduledJob', 'solid-core', moduleRef);
+  }
+}

package/src/services/scheduled-jobs/scheduled-job.interface.ts

@@ -0,0 +1,5 @@
+import { ScheduledJob } from "src/entities/scheduled-job.entity";
+
+export interface IScheduledJob {
+    executeReminder(reminder: ScheduledJob): Promise<void>;
+}

package/src/services/scheduled-jobs/scheduler.interface.ts

@@ -0,0 +1,3 @@
+export interface ISchedulerService {
+    runScheduledJobs(): Promise<void>;
+}

package/src/services/scheduled-jobs/scheduler.service.ts

@@ -0,0 +1,165 @@
+import { Injectable, Logger, Inject } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { LessThanOrEqual, Repository } from 'typeorm';
+
+import { ISchedulerService } from './scheduler.interface';
+import { SolidRegistry } from 'src/helpers/solid-registry';
+import { ScheduledJob } from 'src/entities/scheduled-job.entity';
+import { IScheduledJob } from './scheduled-job.interface';
+import { Cron, CronExpression } from '@nestjs/schedule';
+
+@Injectable()
+export class SchedulerServiceImpl implements ISchedulerService {
+    private readonly logger = new Logger(SchedulerServiceImpl.name);
+
+    constructor(
+        @InjectRepository(ScheduledJob)
+        private readonly scheduledJobRepo: Repository<ScheduledJob>,
+        private readonly solidRegistry: SolidRegistry,
+    ) { }
+
+    // @Cron(CronExpression.EVERY_MINUTE)
+    // async runScheduledJobs(): Promise<void> {
+    //     const now = new Date();
+
+    //     const dueScheduledJobs = await this.scheduledJobRepo.find({
+    //         where: {
+    //             isActive: true,
+    //             nextRunAt: LessThanOrEqual(now),
+    //         },
+    //     });
+
+    //     for (const dueScheduledJob of dueScheduledJobs) {
+    //         try {
+    //             const jobName = dueScheduledJob.job;
+    //             // @ts-ignore                
+    //             // const jobHandler = this.jobMap[jobName];
+    //             // const jobHandler = ''; 
+    //             const jobHandler: IScheduledJob | undefined = this.solidRegistry.getScheduledJobProviderInstance(jobName)
+
+    //             if (!jobHandler) {
+    //                 this.logger.warn(`No job service found for: ${jobName}`);
+    //                 continue;
+    //             }
+
+    //             await jobHandler.executeReminder(dueScheduledJob);
+
+    //             // Update nextRunAt and lastRunAt based on frequency
+    //             dueScheduledJob.lastRunAt = now;
+    //             dueScheduledJob.nextRunAt = this.computeNextRunAt(dueScheduledJob);
+    //             await this.scheduledJobRepo.save(dueScheduledJob);
+
+    //             this.logger.log(`Successfully ran job: ${jobName}`);
+    //         } catch (err) {
+    //             this.logger.error(`Failed to run job for reminder ${dueScheduledJob.id}`, err.stack);
+    //         }
+    //     }
+    // }
+
+    // private computeNextRunAt(reminder: ScheduledJob): Date {
+    //     const now = new Date();
+    //     switch (reminder.frequency) {
+    //         case 'daily':
+    //             return new Date(now.getTime() + 24 * 60 * 60 * 1000);
+    //         case 'weekly':
+    //             return new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000);
+    //         case 'monthly':
+    //             return new Date(now.setMonth(now.getMonth() + 1));
+    //         default:
+    //             return new Date(now.getTime() + 24 * 60 * 60 * 1000); // default fallback
+    //     }
+    // }
+
+    @Cron(CronExpression.EVERY_MINUTE)
+    async runScheduledJobs(): Promise<void> {
+        const now = new Date();
+        const dueJobs = await this.scheduledJobRepo.find({
+            where: {
+                isActive: true,
+                nextRunAt: LessThanOrEqual(now),
+            },
+        });
+
+        for (const job of dueJobs) {
+            try {
+                if (!this.shouldRunNow(job, now)) {
+                    continue;
+                }
+
+                const handler = this.solidRegistry.getScheduledJobProviderInstance(job.job);
+                if (!handler) {
+                    this.logger.warn(`No job handler found for job: ${job.job}`);
+                    continue;
+                }
+
+                await handler.executeReminder(job);
+                job.isActive = true;
+                job.lastRunAt = now;
+                job.nextRunAt = this.computeNextRunAt(job, now);
+                await this.scheduledJobRepo.save(job);
+                this.logger.log(`Successfully ran job: ${job.job}`);
+            } catch (err) {
+                this.logger.error(`Failed to run job ${job.job}`, err.stack);
+            }
+        }
+    }
+
+    private shouldRunNow(job: ScheduledJob, now: Date): boolean {
+        const today = now.toISOString().split('T')[0]; // yyyy-mm-dd
+        const timeNow = now.toTimeString().slice(0, 5); // hh:mm
+
+        // 1. Check startDate / endDate
+        if (job.startDate && new Date(today) < new Date(job.startDate)) return false;
+        if (job.endDate && new Date(today) > new Date(job.endDate)) return false;
+
+        // 2. Check startTime / endTime
+        if (job.startTime) {
+            const jobStart = job.startTime.toTimeString().slice(0, 5);
+            if (timeNow < jobStart) return false;
+        }
+        if (job.endTime) {
+            const jobEnd = job.endTime.toTimeString().slice(0, 5);
+            if (timeNow > jobEnd) return false;
+        }
+
+        // 3. Check dayOfWeek (for weekly)
+        if (job.frequency.toLowerCase() === 'weekly' && job.dayOfWeek) {
+            const todayName = now.toLocaleString('en-US', { weekday: 'long' }); // e.g., "Monday"
+            // const days = job.dayOfWeek.split(',').map(d => d.trim());
+            const days = JSON.parse(job.dayOfWeek) as string[];
+            if (!days.includes(todayName)) return false;
+        }
+
+        // 4. Check dayOfMonth (for monthly)
+        if (job.frequency.toLowerCase() === 'monthly' && job.dayOfMonth) {
+            const dom = now.getDate();
+            if (dom !== job.dayOfMonth) return false;
+        }
+
+        return true;
+    }
+
+    private computeNextRunAt(job: ScheduledJob, from: Date): Date {
+        const base = new Date(from);
+
+        switch (job.frequency.toLowerCase()) {
+            case 'once':
+                return null; // don't reschedule
+            case 'hourly':
+                return new Date(base.getTime() + 60 * 60 * 1000);
+            case 'daily':
+                return new Date(base.getTime() + 24 * 60 * 60 * 1000);
+            case 'weekly':
+                return new Date(base.getTime() + 7 * 24 * 60 * 60 * 1000);
+            case 'monthly':
+                const next = new Date(base);
+                next.setMonth(base.getMonth() + 1);
+                return next;
+            case 'custom':
+                // Optional: let job handler decide via metadata or registry
+                return new Date(base.getTime() + 24 * 60 * 60 * 1000);
+            default:
+                return new Date(base.getTime() + 24 * 60 * 60 * 1000);
+        }
+    }
+}

package/src/services/selection-providers/list-of-scheduled-jobs-selection-provider.service.ts

@@ -0,0 +1,40 @@
+import { Injectable } from "@nestjs/common";
+import { SelectionProvider } from "src/decorators/selection-provider.decorator";
+import { ISelectionProvider, ISelectionProviderContext, ISelectionProviderValues } from "../../interfaces";
+import { SolidRegistry } from "src/helpers/solid-registry";
+import { IScheduledJob } from "../scheduled-jobs/scheduled-job.interface";
+
+
+@SelectionProvider()
+@Injectable()
+export class ListOfScheduledJobsSelectionProvider implements ISelectionProvider<ISelectionProviderContext> {
+
+    constructor(
+        private readonly solidRegistry: SolidRegistry,
+    ) {
+    }
+
+    help(): string {
+        return "# Allows one to dynamically fetch all scheduled jobs";
+    }
+
+    name(): string {
+        return 'ListOfScheduledJobsSelectionProvider';
+    }
+
+    async value(optionValue: string, ctxt: ISelectionProviderContext): Promise<ISelectionProviderValues | any> {
+        const jobHandler: IScheduledJob | undefined = this.solidRegistry.getScheduledJobProviderInstance(optionValue);
+        if (!jobHandler) {
+            return null;
+        }
+
+        return { label: optionValue, value: optionValue };
+    }
+
+    async values(query: string, ctxt: ISelectionProviderContext): Promise<readonly ISelectionProviderValues[]> {
+        const scheduledJobs = this.solidRegistry.getScheduledJobProviders()
+        return scheduledJobs.map(i => {
+            return { label: i.name, value: i.name };
+        });
+    }
+}

package/src/services/sms/Msg91BaseSMSService.ts

@@ -2,17 +2,17 @@ import { Logger } from "@nestjs/common";
 import { ConfigType } from "@nestjs/config";
 import Handlebars from "handlebars";
 import commonConfig from "src/config/common.config";
-import { SmsQueuePublisher } from "src/jobs/sms-publisher.service";
 import { QueueMessage } from "src/interfaces/mq";
 import { SmsTemplateService } from "../sms-template.service";
-import { RabbitMqPublisher } from "src/services/queues/rabbitmq-publisher.service";
 import { ISMS } from "../../interfaces";
+import { PublisherFactory } from "../queues/publisher-factory.service";
 
 export abstract class Msg91BaseSMSService implements ISMS {
     protected readonly logger = new Logger(Msg91BaseSMSService.name);
     constructor(
         protected readonly commonConfiguration: ConfigType<typeof commonConfig>,
-        protected readonly smsPublisher: RabbitMqPublisher<any>,
+        protected readonly smsPublisher: string,
+        protected readonly publisherFactory: PublisherFactory<any>,
         protected readonly smsTemplateService: SmsTemplateService,
     ) { }
 
@@ -71,7 +71,8 @@ export abstract class Msg91BaseSMSService implements ISMS {
     async sendSMSAsynchronously(message) {
         const { to } = message.payload;
         // this.notificationPublisherService.publish(message);
-        this.smsPublisher.publish(message);
+        // this.smsPublisher.publish(message);
+        this.publisherFactory.publish(message, this.smsPublisher);
         this.logger.debug(`Queueing SMS to ${to} with message ${JSON.stringify(message)}`);
     }
 

package/src/services/sms/Msg91OTPService.ts

@@ -2,12 +2,11 @@ import { HttpService } from "@nestjs/axios";
 import { Inject, Injectable } from "@nestjs/common";
 import { ConfigType } from "@nestjs/config";
 import commonConfig from "src/config/common.config";
-import { SmsQueuePublisher } from "src/jobs/sms-publisher.service";
 import { QueueMessage } from "src/interfaces/mq";
 import { SmsTemplateService } from "../sms-template.service";
 import { Msg91BaseSMSService } from "./Msg91BaseSMSService";
-import { OTPQueuePublisher } from "src/jobs/otp-publisher.service";
 import { ISMS } from "../../interfaces";
+import { PublisherFactory } from "../queues/publisher-factory.service";
 
 interface OtpParams {
     otp: string,
@@ -21,16 +20,17 @@ export class Msg91OTPService extends Msg91BaseSMSService implements ISMS {
     constructor(
         @Inject(commonConfig.KEY)
         commonConfiguration: ConfigType<typeof commonConfig>,
-        smsPublisher: OTPQueuePublisher,
+        // smsPublisher: OTPQueuePublisher,
+        publisherFactory: PublisherFactory<any>,
         smsTemplateService: SmsTemplateService,
         private readonly httpService: HttpService,
     ) {
-        super( commonConfiguration, smsPublisher, smsTemplateService )     
-     }
+        super(commonConfiguration, 'OTPQueuePublisher', publisherFactory, smsTemplateService);
+    }
 
     async sendSMSSynchronously(message: QueueMessage<any>): Promise<void> {
         const { to, templateId, otp } = message.payload;
-        const params = {otp, template_id: templateId, mobile: to, authkey: this.commonConfiguration.msg91Sms.apiKey}
+        const params = { otp, template_id: templateId, mobile: to, authkey: this.commonConfiguration.msg91Sms.apiKey }
         const otpUrl = `${this.commonConfiguration.msg91Sms.url}/otp?${this.paramsToQueryString(params)}`;
         await this.httpService.axiosRef.post(otpUrl, {});
         this.logger.debug(`Sending OTP to ${to} with url ${otpUrl}`);
@@ -42,7 +42,7 @@ export class Msg91OTPService extends Msg91BaseSMSService implements ISMS {
         for (const key of paramKeys) {
             qsArray.push(`${key}=${encodeURIComponent(params[key])}`)
         }
-        const qs =  qsArray.join("&");
+        const qs = qsArray.join("&");
         return qs;
     }
 }

package/src/services/sms/Msg91SMSService.ts

@@ -2,23 +2,24 @@ import { HttpService } from "@nestjs/axios";
 import { Inject, Injectable } from "@nestjs/common";
 import { ConfigType } from "@nestjs/config";
 import commonConfig from "src/config/common.config";
-import { SmsQueuePublisher } from "src/jobs/sms-publisher.service";
 import { QueueMessage } from "src/interfaces/mq";
 import { SmsTemplateService } from "../sms-template.service";
 import { Msg91BaseSMSService } from "./Msg91BaseSMSService";
 import { ISMS } from "../../interfaces";
+import { PublisherFactory } from "../queues/publisher-factory.service";
 
 @Injectable()
 export class Msg91SMSService extends Msg91BaseSMSService implements ISMS {
     constructor(
         @Inject(commonConfig.KEY)
         commonConfiguration: ConfigType<typeof commonConfig>,
-        smsPublisher: SmsQueuePublisher,
+        // smsPublisher: SmsQueuePublisher,
+        publisherFactory: PublisherFactory<any>,
         smsTemplateService: SmsTemplateService,
         private readonly httpService: HttpService,
     ) {
-        super( commonConfiguration, smsPublisher, smsTemplateService )     
-     }
+        super(commonConfiguration, 'SmsQueuePublisher', publisherFactory, smsTemplateService)
+    }
 
     async sendSMSSynchronously(message: QueueMessage<any>): Promise<void> {
         const { to, templateId, ...templateParams } = message.payload;

package/src/services/solid-introspect.service.ts

@@ -7,6 +7,7 @@ import { IS_SELECTION_PROVIDER } from 'src/decorators/selection-provider.decorat
 import { IS_SOLID_DATABASE_MODULE } from 'src/decorators/solid-database-module.decorator';
 import { SolidRegistry } from 'src/helpers/solid-registry';
 import { CRUDService } from './crud.service';
+import { IS_SCHEDULED_JOB_PROVIDER } from 'src/decorators/scheduled-job-provider.decorator';
 
 @Injectable()
 export class SolidIntrospectService implements OnApplicationBootstrap {
@@ -81,6 +82,16 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
       .filter((provider) => this.isModule(provider));
     this.solidRegistry.registerModules(allModules);
 
+    // Register all IScheduledJob implementations
+    const scheduledJobProviders = this.discoveryService
+      .getProviders()
+      .filter((provider) => this.isScheduledJobProvider(provider));
+
+    scheduledJobProviders.forEach((scheduledJobProvider) => {
+      // @ts-ignore
+      this.solidRegistry.registerScheduledJobProvider(scheduledJobProvider);
+    });
+
   }
 
   // This method identifies a provider as a seeder if it has a seed method i.e duck typing
@@ -119,6 +130,18 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
     return !!isComputedFieldProvider;
   }
 
+  private isScheduledJobProvider(provider: InstanceWrapper) {
+    const { instance } = provider;
+    if (!instance) return false;
+
+    const isScheduledJobProvider = this.reflector.get<boolean>(
+      IS_SCHEDULED_JOB_PROVIDER,
+      instance.constructor,
+    );
+
+    return !!isScheduledJobProvider;
+  }
+
   private isSolidDatabaseModule(provider: InstanceWrapper) {
     const { instance } = provider;
     if (!instance) return false;

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

@@ -1,5 +1,4 @@
-import { Logger } from '@nestjs/common';
-import { BadRequestException, Injectable } from '@nestjs/common';
+import { BadRequestException, Injectable, Logger } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
@@ -11,17 +10,16 @@ import { ModuleMetadataService } from 'src/services/module-metadata.service';
 import { EntityManager, Repository } from 'typeorm';
 
 
+import { classify } from '@angular-devkit/core/src/utils/strings';
+import { Locale } from 'src/entities/locale.entity';
+import { SolidRegistry } from 'src/helpers/solid-registry';
 import { UpdateViewMetadataDto } from '../dtos/update-view-metadata.dto';
 import { FieldMetadata } from '../entities/field-metadata.entity';
 import { ModelMetadata } from '../entities/model-metadata.entity';
 import { ViewMetadata } from '../entities/view-metadata.entity';
 import { ActionMetadataService } from './action-metadata.service';
 import { SolidIntrospectService } from './solid-introspect.service';
-import { BasicFilterDto } from 'src/dtos/basic-filters.dto';
 import { UserViewMetadataService } from './user-view-metadata.service';
-import { Locale } from 'src/entities/locale.entity';
-import { SolidRegistry } from 'src/helpers/solid-registry';
-import { classify } from '@angular-devkit/core/src/utils/strings';
 
 @Injectable()
 export class ViewMetadataService extends CRUDService<ViewMetadata> {
@@ -45,7 +43,7 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
     private readonly modelMetadataRepo: Repository<ModelMetadata>,
     readonly moduleRef: ModuleRef
   ) {
-    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'viewMetadata', 'app-builder', moduleRef);
+    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'viewMetadata', 'solid-core', moduleRef);
   }
 
   private readonly logger = new Logger(ViewMetadataService.name);
@@ -57,60 +55,60 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
   defaultEntityLocaleIdFromQuery?: string
 ): Promise<{ records: any[], defaultEntityLocaleId: string | null }> {
   const solidRegistry = await this.moduleRef.get(SolidRegistry, { strict: false });
-  const currentEntityTarget = solidRegistry.getEntityTarget(this.entityManager, classify(modelName));
-  const currentEntityRepository = this.entityManager.getRepository(currentEntityTarget);
+  // const currentEntityTarget = solidRegistry.getEntityTarget(this.entityManager, classify(modelName));
+  const currentEntityRepository = this.entityManager.getRepository(classify(modelName));
 
-  // Case 1: Creating a new record with no defaultEntityLocaleId to clone
-  if (id === 'new' && !defaultEntityLocaleIdFromQuery) {
-    this.logger.debug(`Creating new record without cloning from any defaultEntityLocaleId.`);
-    return { records: [], defaultEntityLocaleId: null };
-  }
+    // Case 1: Creating a new record with no defaultEntityLocaleId to clone
+    if (id === 'new' && !defaultEntityLocaleIdFromQuery) {
+      this.logger.debug(`Creating new record without cloning from any defaultEntityLocaleId.`);
+      return { records: [], defaultEntityLocaleId: null };
+    }
 
-  // Case 2: Creating a new record and cloning from an existing defaultEntityLocaleId
-  if (id === 'new' && defaultEntityLocaleIdFromQuery) {
-    this.logger.debug(`Creating new record by cloning translations from defaultEntityLocaleId: ${defaultEntityLocaleIdFromQuery}`);
+    // Case 2: Creating a new record and cloning from an existing defaultEntityLocaleId
+    if (id === 'new' && defaultEntityLocaleIdFromQuery) {
+      this.logger.debug(`Creating new record by cloning translations from defaultEntityLocaleId: ${defaultEntityLocaleIdFromQuery}`);
 
-    const records = await currentEntityRepository.find({
-      where: [
-        { defaultEntityLocaleId: defaultEntityLocaleIdFromQuery },
-        { id: defaultEntityLocaleIdFromQuery }
-      ]
-    });
+      const records = await currentEntityRepository.find({
+        where: [
+          { defaultEntityLocaleId: defaultEntityLocaleIdFromQuery },
+          { id: defaultEntityLocaleIdFromQuery }
+        ]
+      });
 
-    this.logger.debug(`Found ${records.length} cloned records for new entity.`);
-    return { records, defaultEntityLocaleId: defaultEntityLocaleIdFromQuery };
-  }
+      this.logger.debug(`Found ${records.length} cloned records for new entity.`);
+      return { records, defaultEntityLocaleId: defaultEntityLocaleIdFromQuery };
+    }
 
-  // Case 3: Editing an existing entity
-  const entityRecord = await currentEntityRepository.findOne({ where: { id } });
+    // Case 3: Editing an existing entity
+    const entityRecord = await currentEntityRepository.findOne({ where: { id } });
 
-  if (!entityRecord) {
-    this.logger.warn(`No entity found for id ${id}`);
-    return { records: [], defaultEntityLocaleId: null };
-  }
+    if (!entityRecord) {
+      this.logger.warn(`No entity found for id ${id}`);
+      return { records: [], defaultEntityLocaleId: null };
+    }
 
-  const defaultLocale = await this.entityManager.getRepository(Locale).findOne({ where: { isDefault: true } });
+    const defaultLocale = await this.entityManager.getRepository(Locale).findOne({ where: { isDefault: true } });
 
-  let defaultEntityLocaleId: string;
-  if (entityRecord.localeName === defaultLocale?.locale) {
-    defaultEntityLocaleId = entityRecord.id;
-    this.logger.debug(`Editing default locale record with id ${defaultEntityLocaleId}`);
-  } else {
-    defaultEntityLocaleId = entityRecord.defaultEntityLocaleId;
-    this.logger.debug(`Editing non-default locale record. DefaultEntityLocaleId: ${defaultEntityLocaleId}`);
-  }
+    let defaultEntityLocaleId: string;
+    if (entityRecord.localeName === defaultLocale?.locale) {
+      defaultEntityLocaleId = entityRecord.id;
+      this.logger.debug(`Editing default locale record with id ${defaultEntityLocaleId}`);
+    } else {
+      defaultEntityLocaleId = entityRecord.defaultEntityLocaleId;
+      this.logger.debug(`Editing non-default locale record. DefaultEntityLocaleId: ${defaultEntityLocaleId}`);
+    }
 
-  const records = await currentEntityRepository.find({
-    where: [
-      { defaultEntityLocaleId: defaultEntityLocaleId },
-      { id: defaultEntityLocaleId }
-    ]
-  });
+    const records = await currentEntityRepository.find({
+      where: [
+        { defaultEntityLocaleId: defaultEntityLocaleId },
+        { id: defaultEntityLocaleId }
+      ]
+    });
 
-  this.logger.debug(`Found ${records.length} records in all locales for existing entity.`);
+    this.logger.debug(`Found ${records.length} records in all locales for existing entity.`);
 
-  return { records, defaultEntityLocaleId };
-}
+    return { records, defaultEntityLocaleId };
+  }
 
   // START: Custom Service Methods
   async getLayout(query, activeUser) {
@@ -311,10 +309,10 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
     //     }
     //   }
     // }
-    if(entity.model.internationalisation){
+    if (entity.model.internationalisation) {
       const defaultEntityLocaleIdFromQuery = query?.defaultEntityLocaleId;
       const { records: entityRecordsInAllLocales, defaultEntityLocaleId } =
-      await this.getEntityRecordsInAllLocales(modelName, id, defaultEntityLocaleIdFromQuery);
+        await this.getEntityRecordsInAllLocales(modelName, id, defaultEntityLocaleIdFromQuery);
       const allLocales = await this.entityManager.getRepository(Locale).find({});
       for (const locale of allLocales) {
         const matchingRecord = entityRecordsInAllLocales.find(record => record.localeName === locale.locale);

package/src/services/whatsapp/Msg91WhatsappService.ts

@@ -2,11 +2,11 @@ import { HttpService } from '@nestjs/axios';
 import { Inject, Injectable, Logger } from '@nestjs/common';
 import { ConfigType } from '@nestjs/config';
 import commonConfig from 'src/config/common.config';
-import { WhatsappQueuePublisher } from 'src/jobs/whatsapp-publisher.service';
 import { QueueMessage } from 'src/interfaces/mq';
 import { SmsTemplateService } from '../sms-template.service';
 import { Msg91BaseSMSService } from '../sms/Msg91BaseSMSService';
 import { ISMS } from "../../interfaces";
+import { PublisherFactory } from '../queues/publisher-factory.service';
 
 enum Msg91WhatsappParameterHeaderType {
   image,
@@ -57,11 +57,12 @@ export class Msg91WhatsappService extends Msg91BaseSMSService implements ISMS {
   constructor(
     @Inject(commonConfig.KEY)
     commonConfiguration: ConfigType<typeof commonConfig>,
-    whatsappPublisher: WhatsappQueuePublisher,
+    // whatsappPublisher: WhatsappQueuePublisher,
+    publisherFactory: PublisherFactory<any>,
     smsTemplateService: SmsTemplateService,
     private readonly httpService: HttpService,
   ) {
-    super(commonConfiguration, whatsappPublisher, smsTemplateService);
+    super(commonConfiguration, 'WhatsappQueuePublisher', publisherFactory, smsTemplateService);
   }
 
   async sendSMSSynchronously(message: QueueMessage<any>): Promise<void> {