@solidstarters/solid-core 1.2.204 → 1.2.206

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

@@ -20,7 +20,9 @@ import { CreatedByUpdatedBySubscriber } from 'src/subscribers/created-by-updated
 import { SoftDeleteAwareEventSubscriber } from 'src/subscribers/soft-delete-aware-event.subscriber';
 import { DataSource } from 'typeorm';
 import { CRUDService } from './crud.service';
+import { IS_SETTINGS_PROVIDER } from 'src/decorators/settings-provider.decorator';
 import { IS_SMS_PROVIDER } from 'src/decorators/sms-provider.decorator';
+import { SettingService } from 'src/services/setting.service';
 
 export const coreSubscriberClasses = [
   AuditSubscriber,
@@ -37,143 +39,110 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
     private readonly metadataScanner: MetadataScanner,
     private readonly solidRegistry: SolidRegistry,
     private readonly moduleRef: ModuleRef,
+    private readonly settingService: SettingService,
   ) { }
 
   private readonly logger = new Logger(SolidIntrospectService.name);
+
   async onApplicationBootstrap() {
     this.logger.debug('Introspecting the application for Solid metadata');
 
     // Register all seeders
-    const seeders = this.discoveryService
-      .getProviders()
-      .filter((provider) => this.isSeeder(provider));
+    const seeders = this.discoveryService.getProviders().filter((provider) => this.isSeeder(provider));
     seeders.forEach((seeder) => {
       this.solidRegistry.registerSeeder(seeder);
     });
 
-    // TODO: Scan the filesystem and populate the solid metadata
-
     // Register all IErrorCodeProvider implementations
-    const errorCodeProviders = this.discoveryService
-      .getProviders()
-      .filter((provider) => this.isErrorCodeProvider(provider));
-
+    const errorCodeProviders = this.discoveryService.getProviders().filter((provider) => this.isErrorCodeProvider(provider));
     errorCodeProviders.forEach((errorCodeProvider) => {
       this.solidRegistry.registerErrorCodeProvider(errorCodeProvider);
     });
 
     // Register all ISelectionProvider implementations
-    const selectionProviders = this.discoveryService
-      .getProviders()
-      .filter((provider) => this.isSelectionProvider(provider));
-
+    const selectionProviders = this.discoveryService.getProviders().filter((provider) => this.isSelectionProvider(provider));
     selectionProviders.forEach((selectionProvider) => {
       this.solidRegistry.registerSelectionProvider(selectionProvider);
     });
 
-    // Register all IDashboardSelectionProvider implementations
-    const dashboardVariableSelectionProviders = this.discoveryService
-      .getProviders()
-      .filter((provider) => this.isDashboardVariableSelectionProvider(provider));
+    // Register all ISettingsProvider implementations
+    const settingsProviders = this.discoveryService.getProviders().filter((provider) => this.isSettingsProvider(provider));
+    settingsProviders.forEach((settingsProvider) => {
+      this.solidRegistry.registerSettingsProvider(settingsProvider);
+    });
 
+    // Register all IDashboardSelectionProvider implementations
+    const dashboardVariableSelectionProviders = this.discoveryService.getProviders().filter((provider) => this.isDashboardVariableSelectionProvider(provider));
     dashboardVariableSelectionProviders.forEach((dashboardSelectionProvider) => {
       this.solidRegistry.registerDashboardVariableSelectionProvider(dashboardSelectionProvider);
     });
 
     // Register all IDashboardSelectionProvider implementations
-    const dashboardQuestionDataProviders = this.discoveryService
-      .getProviders()
-      .filter((provider) => this.isDashboardQuestionDataProvider(provider));
-
+    const dashboardQuestionDataProviders = this.discoveryService.getProviders().filter((provider) => this.isDashboardQuestionDataProvider(provider));
     dashboardQuestionDataProviders.forEach((provider) => {
       this.solidRegistry.registerDashboardQuestionDataProvider(provider);
     });
 
     // Register all IComputedProvider implementations
-    const computedFieldProviders = this.discoveryService
-      .getProviders()
-      .filter((provider) => this.isComputedFieldProvider(provider));
-
+    const computedFieldProviders = this.discoveryService.getProviders().filter((provider) => this.isComputedFieldProvider(provider));
     computedFieldProviders.forEach((computedFieldProvider) => {
-      // @ts-ignore
       this.solidRegistry.registerComputedFieldProvider(computedFieldProvider);
     });
 
     // Register all ISolidDatabaseModules implementations
-    const solidDatabaseModules = this.discoveryService
-      .getProviders()
-      .filter((provider) => this.isSolidDatabaseModule(provider));
-
+    const solidDatabaseModules = this.discoveryService.getProviders().filter((provider) => this.isSolidDatabaseModule(provider));
     solidDatabaseModules.forEach((solidDatabaseModule) => {
       this.solidRegistry.registerSolidDatabaseModule(solidDatabaseModule);
     });
 
     // keep track of all the controllers & respective methods. 
-    const allControllers = this.discoveryService
-      .getControllers()
-      .map((controller) => {
-        const { instance } = controller;
-        return {
-          name: controller.name,
-          methods: this.metadataScanner.getAllMethodNames(Object.getPrototypeOf(instance))
-        };
-      });
+    const allControllers = this.discoveryService.getControllers().map((controller) => {
+      const { instance } = controller;
+      return {
+        name: controller.name,
+        methods: this.metadataScanner.getAllMethodNames(Object.getPrototypeOf(instance))
+      };
+    });
 
     this.solidRegistry.registerControllers(new Set(allControllers));
 
     // Register all modules
-    const allModules = this.discoveryService
-      .getProviders()
-      .filter((provider) => this.isModule(provider));
+    const allModules = this.discoveryService.getProviders().filter((provider) => this.isModule(provider));
     this.solidRegistry.registerModules(allModules);
 
     // Register all IScheduledJob implementations
-    const scheduledJobProviders = this.discoveryService
-      .getProviders()
-      .filter((provider) => this.isScheduledJobProvider(provider));
-
+    const scheduledJobProviders = this.discoveryService.getProviders().filter((provider) => this.isScheduledJobProvider(provider));
     scheduledJobProviders.forEach((scheduledJobProvider) => {
       this.solidRegistry.registerScheduledJobProvider(scheduledJobProvider);
     });
 
     // Register all IMail implementations
-    const mailProviders = this.discoveryService
-      .getProviders()
-      .filter((provider) => this.isMailProvider(provider));
-
+    const mailProviders = this.discoveryService.getProviders().filter((provider) => this.isMailProvider(provider));
     mailProviders.forEach((mailProvider) => {
       this.solidRegistry.registerMailProvider(mailProvider);
     });
 
     // Register all IWhatsappTransport implementations
-    const whatsappProviders = this.discoveryService
-      .getProviders()
-      .filter((provider) => this.isWhatsappProvider(provider));
-
+    const whatsappProviders = this.discoveryService.getProviders().filter((provider) => this.isWhatsappProvider(provider));
     whatsappProviders.forEach((whatsappProvider) => {
       this.solidRegistry.registerWhatsappProvider(whatsappProvider);
     });
 
     // Register all IWhatsappTransport implementations
-    const smsProviders = this.discoveryService
-      .getProviders()
-      .filter((provider) => this.isSmsProvider(provider));
-
+    const smsProviders = this.discoveryService.getProviders().filter((provider) => this.isSmsProvider(provider));
     smsProviders.forEach((smsProvider) => {
       this.solidRegistry.registerSmsProvider(smsProvider);
     });
 
     // Register all ISecurityRuleConfigProvider implementations
-    const securityRuleConfigProviders = this.discoveryService
-      .getProviders()
-      .filter((provider) => this.isSecurityRuleConfigProvider(provider));
-
+    const securityRuleConfigProviders = this.discoveryService.getProviders().filter((provider) => this.isSecurityRuleConfigProvider(provider));
     securityRuleConfigProviders.forEach((securityRuleConfigProvider) => {
       this.solidRegistry.registerSecurityRuleConfigProvider(securityRuleConfigProvider);
     });
 
     // Register the core subscribers against all the configured database modules / datasources
-    await this.bootstrapCoreTypeOrmSubscribers(solidDatabaseModules)
+    await this.bootstrapCoreTypeOrmSubscribers(solidDatabaseModules);
+    await this.settingService.updateSettingsCache();
   }
 
   async bootstrapCoreTypeOrmSubscribers(dbModules: Array<InstanceWrapper<any>>): Promise<void> {
@@ -261,9 +230,7 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
     const { instance } = provider;
     if (!instance) return false;
 
-    const seedMethod = this.metadataScanner
-      .getAllMethodNames(Object.getPrototypeOf(instance))
-      .find((methodName) => methodName === 'seed');
+    const seedMethod = this.metadataScanner.getAllMethodNames(Object.getPrototypeOf(instance)).find((methodName) => methodName === 'seed');
     if (!seedMethod) return false;
     return true;
   }
@@ -292,6 +259,18 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
     return !!isSelectionProvider;
   }
 
+  private isSettingsProvider(provider: InstanceWrapper) {
+    const { instance } = provider;
+    if (!instance) return false;
+
+    const isSettingsProvider = this.reflector.get<boolean>(
+      IS_SETTINGS_PROVIDER,
+      instance.constructor,
+    );
+
+    return !!isSettingsProvider;
+  }
+
   private isDashboardVariableSelectionProvider(provider: InstanceWrapper) {
     const { instance } = provider;
     if (!instance) return false;

package/src/services/textract.service.ts

@@ -1,7 +1,6 @@
 // src/services/textract.service.ts
 import { Inject, Injectable, Logger } from '@nestjs/common';
 import { ConfigType } from '@nestjs/config';
-import commonConfig, { AwsS3Config } from '../config/common.config';
 import {
     TextractClient,
     StartDocumentTextDetectionCommand,
@@ -12,6 +11,7 @@ import {
 } from '@aws-sdk/client-textract';
 import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
 import * as fs from 'node:fs';
+import { AwsS3Config } from 'src/interfaces';
 
 @Injectable()
 export class TextractService {
@@ -20,23 +20,26 @@ export class TextractService {
     private readonly s3Client: S3Client;
 
     constructor(
-        @Inject(commonConfig.KEY)
-        private readonly commonConfiguration: ConfigType<typeof commonConfig>,
     ) {
-        if (!this.isValidS3Config(this.commonConfiguration.awsS3Credentials)) { return }
+        const awsS3Credentials = {
+            S3_AWS_ACCESS_KEY: process.env.S3_AWS_ACCESS_KEY,
+            S3_AWS_SECRET_KEY: process.env.S3_AWS_SECRET_KEY,
+            S3_AWS_REGION_NAME: process.env.S3_AWS_REGION_NAME
+        }
+        if (!this.isValidS3Config(awsS3Credentials)) { return }
         this.s3Client = new S3Client({
-            region: this.commonConfiguration.awsS3Credentials.S3_AWS_REGION_NAME,
+            region: process.env.S3_AWS_REGION_NAME,
             credentials: {
-                accessKeyId: this.commonConfiguration.awsS3Credentials.S3_AWS_ACCESS_KEY,
-                secretAccessKey: this.commonConfiguration.awsS3Credentials.S3_AWS_SECRET_KEY,
+                accessKeyId: process.env.S3_AWS_ACCESS_KEY,
+                secretAccessKey: process.env.S3_AWS_SECRET_KEY,
             },
         });
 
         this.textractClient = new TextractClient({
-            region: this.commonConfiguration.awsS3Credentials.S3_AWS_REGION_NAME,
+            region: process.env.S3_AWS_REGION_NAME,
             credentials: {
-                accessKeyId: this.commonConfiguration.awsS3Credentials.S3_AWS_ACCESS_KEY,
-                secretAccessKey: this.commonConfiguration.awsS3Credentials.S3_AWS_SECRET_KEY,
+                accessKeyId: process.env.S3_AWS_ACCESS_KEY,
+                secretAccessKey: process.env.S3_AWS_SECRET_KEY,
             },
         });
     }

package/src/services/user-activity-history.service.ts

@@ -1,14 +1,9 @@
-import { forwardRef, Inject, Injectable } from '@nestjs/common';
-import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
-import { DiscoveryService, ModuleRef } from "@nestjs/core";
-import { EntityManager, In, Repository } from 'typeorm';
+import { Injectable } from '@nestjs/common';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { ModuleRef } from "@nestjs/core";
+import { EntityManager } from 'typeorm';
 
 import { CRUDService } from 'src/services/crud.service';
-import { ModelMetadataService } from 'src/services/model-metadata.service';
-import { ModuleMetadataService } from 'src/services/module-metadata.service';
-import { ConfigService } from '@nestjs/config';
-import { FileService } from 'src/services/file.service';
-import { CrudHelperService } from 'src/services/crud-helper.service';
 
 
 import { UserActivityHistory } from '../entities/user-activity-history.entity';
@@ -19,13 +14,6 @@ import { UserActivityHistoryRepository } from 'src/repository/user-activity-hist
 @Injectable()
 export class UserActivityHistoryService extends CRUDService<UserActivityHistory> {
   constructor(
-    @Inject(forwardRef(() => ModelMetadataService))
-    readonly modelMetadataService: ModelMetadataService,
-    readonly moduleMetadataService: ModuleMetadataService,
-    readonly configService: ConfigService,
-    readonly fileService: FileService,
-    readonly discoveryService: DiscoveryService,
-    readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
     // @InjectRepository(UserActivityHistory, 'default')
@@ -35,7 +23,7 @@ export class UserActivityHistoryService extends CRUDService<UserActivityHistory>
     readonly requestContextService: RequestContextService,
 
   ) {
-    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'userActivityHistory', 'solid-core', moduleRef);
+    super(entityManager, repo, 'userActivityHistory', 'solid-core', moduleRef);
   }
   async logEvent(event: 'login' | 'logout' | 'tokenRefreshed', user: User) {
     const ip = this.requestContextService.getIp();

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

@@ -1,14 +1,9 @@
-import { forwardRef, Inject, Injectable } from '@nestjs/common';
-import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
-import { DiscoveryService, ModuleRef } from "@nestjs/core";
-import { EntityManager, Repository } from 'typeorm';
+import { Injectable } from '@nestjs/common';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { ModuleRef } from "@nestjs/core";
+import { EntityManager } from 'typeorm';
 
 import { CRUDService } from 'src/services/crud.service';
-import { ModelMetadataService } from 'src/services/model-metadata.service';
-import { ModuleMetadataService } from 'src/services/module-metadata.service';
-import { ConfigService } from '@nestjs/config';
-import { FileService } from 'src/services/file.service';
-import { CrudHelperService } from 'src/services/crud-helper.service';
 
 
 import { UserViewMetadata } from '../entities/user-view-metadata.entity';
@@ -19,13 +14,6 @@ import { UserViewMetadataRepository } from 'src/repository/user-view-metadata.re
 @Injectable()
 export class UserViewMetadataService extends CRUDService<UserViewMetadata> {
   constructor(
-    @Inject(forwardRef(() => ModelMetadataService))
-    readonly modelMetadataService: ModelMetadataService,
-    readonly moduleMetadataService: ModuleMetadataService,
-    readonly configService: ConfigService,
-    readonly fileService: FileService,
-    readonly discoveryService: DiscoveryService,
-    readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
     // @InjectRepository(UserViewMetadata, 'default')
@@ -34,7 +22,7 @@ export class UserViewMetadataService extends CRUDService<UserViewMetadata> {
     readonly moduleRef: ModuleRef
 
   ) {
-    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'userViewMetadata', 'solid-core', moduleRef);
+    super(entityManager, repo, 'userViewMetadata', 'solid-core', moduleRef);
   }
 
   async upsert(query: UpsertUserViewMetadataDto, activeUser: ActiveUserData) {

package/src/services/user.service.ts

@@ -1,20 +1,15 @@
 import { BadRequestException, forwardRef, Inject, Injectable } from '@nestjs/common';
-import { ConfigService, ConfigType } from '@nestjs/config';
-import { DiscoveryService, ModuleRef } from "@nestjs/core";
+import { ModuleRef } from "@nestjs/core";
 import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
-import { CrudHelperService } from "src/services/crud-helper.service";
 import { CRUDService } from 'src/services/crud.service';
-import { FileService } from "src/services/file.service";
-import { ModelMetadataService } from 'src/services/model-metadata.service';
-import { ModuleMetadataService } from 'src/services/module-metadata.service';
 import { EntityManager, Repository } from 'typeorm';
+import type { SolidCoreSetting } from "src/services/settings/default-settings-provider.service";
 
 
 import { OauthUserDto } from '../dtos/oauth-user-dto';
 import { RoleMetadata } from '../entities/role-metadata.entity';
 import { User } from '../entities/user.entity';
 import { ActiveUserData } from '../interfaces/active-user-data.interface';
-import { iamConfig } from 'src/config/iam.config';
 import { ERROR_MESSAGES } from 'src/constants/error-messages';
 import { UserRepository } from 'src/repository/user.repository';
 import { RoleMetadataRepository } from 'src/repository/role-metadata.repository';
@@ -23,30 +18,20 @@ import { HashingService } from './hashing.service';
 @Injectable()
 export class UserService extends CRUDService<User> {
   constructor(
-    @Inject(forwardRef(() => ModelMetadataService))
-    readonly modelMetadataService: ModelMetadataService,
-    readonly moduleMetadataService: ModuleMetadataService,
-    readonly configService: ConfigService,
-    readonly fileService: FileService,
-    readonly discoveryService: DiscoveryService,
-    readonly crudHelperService: CrudHelperService,
     readonly hashingService: HashingService,
-    
     @InjectEntityManager()
     readonly entityManager: EntityManager,
     // @InjectRepository(User, 'default')
     readonly repo: UserRepository,
     @InjectRepository(User, 'default')
-    readonly nonSecurityRuleAwareRepo : Repository<User>,
+    readonly nonSecurityRuleAwareRepo: Repository<User>,
     // @InjectRepository(RoleMetadata)
     // private readonly roleRepository: Repository<RoleMetadata>,
     private readonly roleRepository: RoleMetadataRepository,
     readonly moduleRef: ModuleRef,
-    @Inject(iamConfig.KEY)
-    private readonly iamConfiguration: ConfigType<typeof iamConfig>,
 
   ) {
-    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'user', 'solid-core', moduleRef);
+    super(entityManager, repo, 'user', 'solid-core', moduleRef);
   }
 
   override async delete(id: number, solidRequestContext: any = {}) {
@@ -234,7 +219,7 @@ export class UserService extends CRUDService<User> {
       const savedUser = await this.repo.save(user);
 
       // Initialize the user roles
-      this.initializeRolesForNewUser([this.iamConfiguration.defaultRole], savedUser);
+      await this.initializeRolesForNewUser([this.settingService.getConfigValue<SolidCoreSetting>('defaultRole')], savedUser);
     }
     // else we update the user and store the generated code & access token. 
     else {
@@ -292,14 +277,14 @@ export class UserService extends CRUDService<User> {
     passwordSchemeVersion: number;
   }> {
     const hashedPassword = await this.hashingService.hash(password);
-  
+
     return {
       password: hashedPassword,
       passwordScheme: this.hashingService.name(),
       passwordSchemeVersion: this.hashingService.currentVersion(),
     };
   }
-  
+
 
 }
 

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

@@ -1,13 +1,8 @@
 import { BadRequestException, forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-import { DiscoveryService, ModuleRef } from "@nestjs/core";
+import { ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
-import { CrudHelperService } from "src/services/crud-helper.service";
 import { CRUDService } from 'src/services/crud.service';
-import { FileService } from "src/services/file.service";
-import { ModelMetadataService } from 'src/services/model-metadata.service';
-import { ModuleMetadataService } from 'src/services/module-metadata.service';
-import { EntityManager, In } from 'typeorm';
+import { EntityManager } from 'typeorm';
 
 
 import { classify } from '@angular-devkit/core/src/utils/strings';
@@ -27,13 +22,6 @@ import { UserViewMetadataService } from './user-view-metadata.service';
 @Injectable()
 export class ViewMetadataService extends CRUDService<ViewMetadata> {
   constructor(
-    @Inject(forwardRef(() => ModelMetadataService))
-    readonly modelMetadataService: ModelMetadataService,
-    readonly moduleMetadataService: ModuleMetadataService,
-    readonly configService: ConfigService,
-    readonly fileService: FileService,
-    readonly discoveryService: DiscoveryService,
-    readonly crudHelperService: CrudHelperService,
     readonly actionMetadataService: ActionMetadataService,
     readonly menuItemMetadataService: MenuItemMetadataService,
     readonly introspectService: SolidIntrospectService,
@@ -51,7 +39,7 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
     private readonly modelMetadataHelperService: ModelMetadataHelperService,
     readonly moduleRef: ModuleRef
   ) {
-    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'viewMetadata', 'solid-core', moduleRef);
+    super(entityManager, repo, 'viewMetadata', 'solid-core', moduleRef);
   }
 
   private readonly logger = new Logger(ViewMetadataService.name);

package/src/services/whatsapp/Msg91WhatsappService.ts

@@ -1,11 +1,12 @@
 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 { QueueMessage } from 'src/interfaces/mq';
 import { IWhatsAppTransport } from "../../interfaces";
 import { PublisherFactory } from '../queues/publisher-factory.service';
 import { WhatsAppProvider } from 'src/decorators/whatsapp-provider.decorator';
+import { SettingService } from '../setting.service';
+import type { SolidCoreSetting } from "src/services/settings/default-settings-provider.service";
 
 enum Msg91WhatsappParameterHeaderType {
   image,
@@ -55,12 +56,11 @@ export class Msg91WhatsappService implements IWhatsAppTransport {
   readonly logger = new Logger(Msg91WhatsappService.name);
 
   constructor(
-    @Inject(commonConfig.KEY)
-    private readonly commonConfiguration: ConfigType<typeof commonConfig>,
     // whatsappPublisher: WhatsappQueuePublisher,
     private readonly publisherFactory: PublisherFactory<any>,
     private readonly httpService: HttpService,
-  ) {}
+    private readonly settingService: SettingService
+  ) { }
 
   async sendWhatsAppMessage(
     to: string,
@@ -90,19 +90,19 @@ export class Msg91WhatsappService implements IWhatsAppTransport {
   }
 
   async sendWhatsAppMessageSynchronously(message: QueueMessage<any>): Promise<void> {
-    const body = this.createWhatsappRequest(message);
-    const headers = { authkey: this.commonConfiguration.msg91Whatsapp.apiKey };
+    const body = await this.createWhatsappRequest(message);
+    const headers = { authkey: this.settingService.getConfigValue<SolidCoreSetting>("msg91WhatsappApiKey") };
     await this.httpService.axiosRef.post(
-      `${this.commonConfiguration.msg91Whatsapp.url}`,
+      `${this.settingService.getConfigValue<SolidCoreSetting>("msg91WhatsappUrl")}`,
       body,
       { headers },
     );
     this.logger.debug(
-      `Sending Whatsapp message for CP registration with body ${JSON.stringify(body)} and url ${this.commonConfiguration.msg91Whatsapp.url}`,
+      `Sending Whatsapp message for CP registration with body ${JSON.stringify(body)} and url ${this.settingService.getConfigValue<SolidCoreSetting>("msg91WhatsappUrl")}`,
     );
   }
 
-  private createWhatsappRequest(message: QueueMessage<any>): WhatsappRequest {
+  private async createWhatsappRequest(message: QueueMessage<any>): Promise<WhatsappRequest> {
     const { to, templateId, ...parameters } = message.payload;
     const whatsappToAndComponents = this.createWhatsappToAndComponents(
       to,
@@ -123,8 +123,7 @@ export class Msg91WhatsappService implements IWhatsAppTransport {
       template: whatsappTemplate,
     };
     return {
-      integrated_number:
-        this.commonConfiguration.msg91Whatsapp.integratedNumber,
+      integrated_number: this.settingService.getConfigValue<SolidCoreSetting>("msg91WhatsappIntegratedNumber"),
       content_type: 'template',
       payload: whatsappPayload,
     };

package/src/services/whatsapp/Three60WhatsappService.ts

@@ -1,7 +1,6 @@
 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 { QueueMessage } from 'src/interfaces/mq';
 import { IWhatsAppTransport } from "../../interfaces";
 import { PublisherFactory } from '../queues/publisher-factory.service';
@@ -13,8 +12,6 @@ export class Three60WhatsappService implements IWhatsAppTransport {
   readonly logger = new Logger(Three60WhatsappService.name);
 
   constructor(
-    @Inject(commonConfig.KEY)
-    private readonly commonConfiguration: ConfigType<typeof commonConfig>,
     private readonly publisherFactory: PublisherFactory<any>,
     private readonly httpService: HttpService,
   ) { }