@solidstarters/solid-core 1.2.200 → 1.2.202

package/src/helpers/field-crud-managers/ManyToOneRelationFieldCrudManager.ts

@@ -1,4 +1,5 @@
 import { classify } from "@angular-devkit/core/src/utils/strings";
+import { BadRequestException } from "@nestjs/common";
 import { isEmpty, isNotEmpty, isString } from "class-validator";
 import { FieldCrudManager, ValidationError } from "src/interfaces";
 import { IsParsableInt } from "src/validators/is-parsable-int";
@@ -64,16 +65,23 @@ export class ManyToOneRelationFieldCrudManager implements FieldCrudManager {
         // Avoid transforming if both fieldId and fieldUserKey  is empty
         if ((isEmpty(fieldId)) && isEmpty(fieldUserKeyValue)) return dto;
 
+         if (!this.options.relationCoModelSingularName) {
+            throw new BadRequestException(`ManyToOneRelationFieldCrudManager: relationCoModelSingularName is not defined in the field: ${this.options.fieldName}`);
+        }
         // // Load the related entity from the database, using the repository of the related entity
-        const entityTarget = this.getRelatedEntityTarget(classify(this.options.relationCoModelSingularName));
+        //const entityTarget = this.getRelatedEntityTarget(classify(this.options.relationCoModelSingularName));
+        const coModelEntityName = classify(this.options.relationCoModelSingularName);
+
+        //Load the related entity from the database, using the repository of the related entity
+        //const entityTarget = this.getRelatedEntityTarget(classify(this.options.relationCoModelSingularName));
         if (isNotEmpty(fieldId)) {
-            dto[this.options.fieldName] = await this.options.entityManager.getRepository(entityTarget).findOneBy({ id: fieldId });
+            dto[this.options.fieldName] = await this.options.entityManager.getRepository(coModelEntityName).findOneBy({ id: fieldId });
             if (this.options.required && isEmpty(dto[this.options.fieldName])) {
                 throw new Error(`ManyToOneRelationFieldCrudManager: Record with id: ${fieldId} not found in ${this.options.relationCoModelSingularName}`);
             }
         }
         else {
-            dto[this.options.fieldName] = await this.options.entityManager.getRepository(entityTarget).findOneBy({ [this.options.relationCoModelUserKeyFieldName]: fieldUserKeyValue });
+            dto[this.options.fieldName] = await this.options.entityManager.getRepository(coModelEntityName).findOneBy({ [this.options.relationCoModelUserKeyFieldName]: fieldUserKeyValue });
             if (this.options.required && isEmpty(dto[this.options.fieldName])) {
                 throw new Error(`ManyToOneRelationFieldCrudManager: Record with userKey: ${this.options.relationCoModelUserKeyFieldName}: ${fieldUserKeyValue} not found in ${this.options.relationCoModelSingularName}`);
             }
@@ -88,10 +96,10 @@ export class ManyToOneRelationFieldCrudManager implements FieldCrudManager {
     }
 
     // Returns the entity target class from the entity name
-    private getRelatedEntityTarget(relatedEntityName: string): any {
-        const entityMetadatas = this.options.entityManager.connection.entityMetadatas;
-        const relatedEntityMetadata = entityMetadatas.find(em => em.name === relatedEntityName);
-        return relatedEntityMetadata.target;
-    }
+    // private getRelatedEntityTarget(relatedEntityName: string): any {
+    //     const entityMetadatas = this.options.entityManager.connection.entityMetadatas;
+    //     const relatedEntityMetadata = entityMetadatas.find(em => em.name === relatedEntityName);
+    //     return relatedEntityMetadata.target;
+    // }
 
 }

package/src/helpers/field-crud-managers/OneToManyRelationFieldCrudManager.ts

@@ -75,11 +75,11 @@ export class OneToManyRelationFieldCrudManager implements FieldCrudManager {
 
     async transformForCreate(dto: any): Promise<any> {
         // const relatedFieldData: any[] = dto[this.fieldName()];
-        const currentEntityTarget = this.getEntityTarget(classify(this.options.modelSingularName));
-        const currentEntityRepository = this.options.entityManager.getRepository(currentEntityTarget);
+        const currentEntityName = classify(this.options.modelSingularName);
+        const currentEntityRepository = this.options.entityManager.getRepository(currentEntityName);
 
-        const relatedEntityTarget = this.getEntityTarget(classify(this.options.relationCoModelSingularName));
-        const relatedEntityRepository = this.options.entityManager.getRepository(relatedEntityTarget)
+        const relatedEntityName = classify(this.options.relationCoModelSingularName);
+        const relatedEntityRepository = this.options.entityManager.getRepository(relatedEntityName);
 
         dto[this.valueFieldName] = await this.transformByCommand(dto, relatedEntityRepository, currentEntityRepository);
         return dto;
@@ -197,9 +197,9 @@ export class OneToManyRelationFieldCrudManager implements FieldCrudManager {
 
     // TODO: We have moved this to SolidRegistry service, refactor to use that service.
     // Returns the entity target class from the entity name
-    private getEntityTarget(entityName: string): any { //TODO Can be refactored to use this function from crud helper service
-        const entityMetadatas = this.options.entityManager.connection.entityMetadatas;
-        const entityMetadata = entityMetadatas.find(em => em.name === entityName);
-        return entityMetadata.target;
-    }
+    // private getEntityTarget(entityName: string): any { //TODO Can be refactored to use this function from crud helper service
+    //     const entityMetadatas = this.options.entityManager.connection.entityMetadatas;
+    //     const entityMetadata = entityMetadatas.find(em => em.name === entityName);
+    //     return entityMetadata.target;
+    // }
 }

package/src/helpers/model-metadata-helper.service.ts

@@ -1,18 +1,20 @@
 // Return the system fields metadata for a model
 
-import { Injectable, Logger } from "@nestjs/common";
+import { forwardRef, Inject, Injectable, Logger } from "@nestjs/common";
+import { _ } from "lodash";
+import { LEGACY_TABLE_FIELDS_PREFIX } from "src/entities/legacy-common.entity";
 import { ModelMetadataRepository } from "src/repository/model-metadata.repository";
 import { SolidRegistry } from "./solid-registry";
-import {_ } from "lodash";
-import { LEGACY_TABLE_FIELDS_PREFIX } from "src/entities/legacy-common.entity";
 
 @Injectable()
 export class ModelMetadataHelperService {
     private readonly logger = new Logger(ModelMetadataHelperService.name);
 
-    constructor(private readonly registry: SolidRegistry,
+    constructor(
+        private readonly registry: SolidRegistry,
         // @InjectRepository(ModelMetadata)
         // private readonly modelMetadataRepo: Repository<ModelMetadata>,
+        @Inject(forwardRef(() => ModelMetadataRepository))
         private readonly modelMetadataRepo: ModelMetadataRepository,
     ) {
     }

package/src/helpers/module-metadata-helper.service.ts

@@ -57,4 +57,21 @@ export class ModuleMetadataHelperService {
         }
         return filePath;
     }
-}
+    async getModuleMetadataFolderPath(moduleName: string): Promise<string> {
+        if (!moduleName) {
+            return '';
+        }
+
+        const dashModuleName = dasherize(moduleName);
+
+        const folderPath = path.resolve(
+            process.cwd(),
+            'module-metadata',
+            dashModuleName,
+        );
+
+        const exists = await this.fileService.pathExists(folderPath);
+        return exists ? folderPath : '';
+    }
+
+}

package/src/helpers/module.helper.ts

@@ -1,6 +1,8 @@
+import { Logger } from '@nestjs/common';
 import * as fs from 'fs'; // Use the Promise-based version of fs for async/await
 import * as path from 'path'; // To handle file paths
 
+const logger = new Logger('module.helper');
 
 export const getDynamicModuleNames = (): string[] => {
   const dynamicModulesToExclude = process.env.SOLID_DYNAMIC_MODULES_TO_EXCLUDE?.split(',') || [];
@@ -21,15 +23,48 @@ export const getDynamicModuleNames = (): string[] => {
 
       if (!isValidDirectory) return false;
 
-      return true
-      // const fullPath = path.join(srcPath, dirent.name);
-      // const files = fs.readdirSync(fullPath);
+      // return true
+      const fullPath = path.join(srcPath, dirent.name);
+      const files = fs.readdirSync(fullPath);
       // skip if empty directory
-      // return files.length > 0;
+      return files.length > 0;
     })
     .map(dirent => dirent.name);
 
-  console.log(`Enabled dynamic modules:`, enabledModules);
+  // logger.debug(`Enabled dynamic modules:`, enabledModules);
+  return enabledModules;
+}
+
+export const getDynamicModuleNamesBasedOnMetadata = (): string[] => {
+  const dynamicModulesToExclude = process.env.SOLID_DYNAMIC_MODULES_TO_EXCLUDE?.split(',') || [];
+
+  // Find a path that is ../${srcPath}/module-metadata save it in a variable.
+  // const srcPath = path.join(process.cwd(), 'src');
+  const moduleMetadataPath = path.join(process.cwd(), 'module-metadata');
+  const coreModuleNames = getCoreModuleNames();
+  const allExcludedModules = [...new Set([...coreModuleNames, ...dynamicModulesToExclude])];
+
+  // if module-metadata path does not exist, return empty array
+  if (!fs.existsSync(moduleMetadataPath)) {
+    logger.warn(`Module metadata path does not exist: ${moduleMetadataPath}`);
+    return [];
+  }
+
+  const moduleMetadataDirectories = fs.readdirSync(moduleMetadataPath, { withFileTypes: true });
+  const enabledModules = moduleMetadataDirectories
+    .filter(dirent => {
+      const isValidDirectory = dirent.isDirectory() && !allExcludedModules.includes(dirent.name);
+
+      if (!isValidDirectory) return false;
+
+      const fullPath = path.join(moduleMetadataPath, dirent.name, `${dirent.name}-metadata.json`);
+
+      const stats = fs.statSync(fullPath, { throwIfNoEntry: false });
+      return !!stats && stats.isFile();
+    })
+    .map(dirent => dirent.name);
+
+  // logger.debug(`Enabled dynamic modules basis src:`, enabledModules);
   return enabledModules;
 }
 

package/src/helpers/solid-registry.ts

@@ -7,6 +7,9 @@ import { SecurityRule } from 'src/entities/security-rule.entity';
 import { IScheduledJob } from 'src/services/scheduled-jobs/scheduled-job.interface';
 import { IDashboardQuestionDataProvider, IDashboardVariableSelectionProvider, IErrorCodeProvider, ISecurityRuleConfigProvider, ISelectionProvider, ISelectionProviderContext, ISolidDatabaseModule } from "../interfaces";
 import { DatasourceType } from 'src/dtos/create-model-metadata.dto';
+import { ObjectLiteral } from 'typeorm';
+import { ColumnMetadata } from 'typeorm/metadata/ColumnMetadata';
+import { RelationMetadata } from 'typeorm/metadata/RelationMetadata';
 
 type ControllerMetadata = {
   name: string;
@@ -39,6 +42,16 @@ export enum RESERVED_SOLID_KEYWORDS {
   locale = "locale"
 }
 
+export interface TypeOrmEventContext {
+  eventType?: string;
+  entity?: ObjectLiteral | undefined;
+  databaseEntity?: any;
+  entityId?: any;
+  metadataName?: string;
+  updatedColumns?: string[];
+  updatedRelations?: string[];
+}
+
 export interface ComputedFieldMetadata<TContext = any> {
   moduleName: string; // Name of the module where the computed field is defined
   modelName: string; // Name of the model where the computed field is defined
@@ -49,6 +62,7 @@ export interface ComputedFieldMetadata<TContext = any> {
   computedFieldValueProviderName: string; // Name of the provider that computes the field value
   // Example: '{"contextKey": "contextValue"}'
   computedFieldValueProviderCtxt: TContext; // Context for the computed field value
+  eventContext: TypeOrmEventContext;
 }
 
 @Injectable()
@@ -67,6 +81,7 @@ export class SolidRegistry {
   private dashboardQuestionDataProviders: Set<InstanceWrapper> = new Set();
   private mailProviders: Set<InstanceWrapper> = new Set();
   private whatsappProviders: Set<InstanceWrapper> = new Set();
+  private smsProviders: Set<InstanceWrapper> = new Set();
   private securityRuleConfigProviders: Set<InstanceWrapper> = new Set();
   private errorCodeProviders: Set<InstanceWrapper> = new Set();
 
@@ -78,6 +93,10 @@ export class SolidRegistry {
     this.whatsappProviders.add(whatsappProvider);
   }
 
+  registerSmsProvider(smsProvider: InstanceWrapper): void {
+    this.smsProviders.add(smsProvider);
+  }
+
   registerSecurityRuleConfigProvider(securityRuleConfigProvider: InstanceWrapper): void {
     this.securityRuleConfigProviders.add(securityRuleConfigProvider);
   }
@@ -134,6 +153,10 @@ export class SolidRegistry {
     return Array.from(this.whatsappProviders);
   }
 
+  getSmsProviders(): Array<InstanceWrapper> {
+    return Array.from(this.smsProviders);
+  }
+
   getSecurityRuleConfigProviders(): Array<InstanceWrapper> {
     return Array.from(this.securityRuleConfigProviders);
   }

package/src/index.ts

@@ -24,6 +24,7 @@ export * from './decorators/solid-database-module.decorator'
 export * from './decorators/solid-service.decorator'
 export * from './decorators/mail-provider.decorator'
 export * from './decorators/security-rule-config-provider.decorator'
+export * from './decorators/sms-provider.decorator'
 
 export * from './dtos/post-chatter-message.dto'
 export * from './dtos/security-rule-config.dto'
@@ -137,6 +138,7 @@ export * from './entities/dashboard-variable.entity'
 export * from './entities/dashboard-question.entity'
 export * from './entities/dashboard-question-sql-dataset-config.entity'
 export * from './entities/ai-interaction.entity'
+export * from './entities/model-sequence.entity'
 
 export * from './enums/auth-type.enum'
 export * from './decorators/disallow-in-production.decorator'
@@ -193,12 +195,12 @@ export * from './jobs/api-email-subscriber.service'
 export { SmtpEmailQueuePublisherRabbitmq, SmtpEmailQueuePublisherRabbitmq as EmailQueuePublisher } from './jobs/smtp-email-publisher.service' // alias for backward compatibility
 export * from './jobs/smtp-email-queue-options'
 export { SmtpEmailQueueSubscriberRabbitmq, SmtpEmailQueueSubscriberRabbitmq as EmailQueueSubscriber } from './jobs/smtp-email-subscriber.service' // alias for backward compatibility
-export * from './jobs/otp-publisher.service'
-export * from './jobs/otp-queue-options'
-export * from './jobs/otp-subscriber.service'
-export * from './jobs/sms-publisher.service'
-export * from './jobs/sms-queue-options'
-export * from './jobs/sms-subscriber.service'
+export * from './jobs/msg91-otp-publisher.service'
+export * from './jobs/msg91-otp-queue-options'
+export * from './jobs/msg91-otp-subscriber.service'
+export * from './jobs/msg91-sms-publisher.service'
+export * from './jobs/msg91-sms-queue-options'
+export * from './jobs/msg91-sms-subscriber.service'
 export * from './jobs/msg91-whatsapp-publisher.service'
 export * from './jobs/msg91-whatsapp-queue-options'
 export * from './jobs/msg91-whatsapp-subscriber.service'
@@ -280,6 +282,8 @@ export * from './services/ai-interaction.service'
 
 // Factories
 export * from './factories/mail.factory'
+export * from './factories/sms.factory'
+export * from './factories/whatsapp.factory'
 
 // Repositories
 export * from './repository/solid-base.repository'
@@ -299,6 +303,8 @@ export * from './subscribers/audit.subscriber'
 export * from './transformers/array-transformer'
 export * from './transformers/boolean-transformer'
 export * from './transformers/integer-transformer'
+export { default as datetimeTransformer } from './transformers/datetime-transformer'
+export * from './transformers/typeorm/local-date-time-transformer'
 
 export * from './validators/is-parsable-int'
 
@@ -307,6 +313,5 @@ export * from './interfaces'
 export * from './solid-core.module'
 
 export * from './winston.logger'
-export { default as datetimeTransformer } from './transformers/datetime-transformer'
 
 export { ERROR_MESSAGES } from './constants/error-messages'

package/src/jobs/computed-field-evaluation-subscriber.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from "@nestjs/common";
+import { Injectable, Logger } from "@nestjs/common";
 import { SolidRegistry } from "src/helpers/solid-registry";
 import { IEntityPostComputeFieldProvider, QueuesModuleOptions } from "src/interfaces";
 import { QueueMessage } from "src/interfaces/mq";
@@ -11,6 +11,7 @@ import computedFieldEvaluationQueueOptions from "./computed-field-evaluation-que
 
 @Injectable()
 export class ComputedFieldEvaluationSubscriberRabbitmq extends RabbitMqSubscriber<ComputedFieldEvaluationPayload> {
+    private readonly _logger = new Logger(ComputedFieldEvaluationSubscriberRabbitmq.name);
     constructor(
         readonly mqMessageService: MqMessageService,
         readonly mqMessageQueueService: MqMessageQueueService,
@@ -30,9 +31,19 @@ export class ComputedFieldEvaluationSubscriberRabbitmq extends RabbitMqSubscribe
     // It will then call the corresponding provider computeAndSave method to perform the evaluation
     async subscribe(message: QueueMessage<ComputedFieldEvaluationPayload>) {
         const { databaseEntity, ...computedFieldMetadata } = message.payload;
-        const provider = this.solidRegistry.getComputedFieldProvider(computedFieldMetadata.computedFieldValueProviderName);
+        const { computedFieldValueProviderName } = computedFieldMetadata;
+        const provider = this.solidRegistry.getComputedFieldProvider(computedFieldValueProviderName);
         // Get the instance of the provider and assert it is of type IEntityComputedFieldProvider
         const providerInstance = provider.instance as IEntityPostComputeFieldProvider<any, any>; // IEntityComputedFieldProvider
-        await providerInstance.postComputeAndSaveValue(databaseEntity, computedFieldMetadata); //FIXME There should some way to check/assert if the provider actually has a postComputeAndSaveValue
+        if (typeof providerInstance.postComputeAndSaveValue !== 'function') {
+            this._logger.warn(`Provider "${computedFieldValueProviderName}" does not implement postComputeAndSaveValue; skipping post-compute.`);
+            return;
+        }
+        await providerInstance.postComputeAndSaveValue(databaseEntity, {
+            ...computedFieldMetadata,
+            computedFieldValueProviderCtxt: {
+                ...(computedFieldMetadata.computedFieldValueProviderCtxt || {}),
+            },
+        }); //FIXME There should some way to check/assert if the provider actually has a postComputeAndSaveValue
     }
-}
+}

package/src/jobs/database/{sms-publisher-database.service.ts → msg91-sms-publisher-database.service.ts}

@@ -1,13 +1,13 @@
 import { Injectable } from '@nestjs/common';
 
-import smsQueueOptions from './sms-queue-database-options';
+import smsQueueOptions from './msg91-sms-queue-database-options';
 import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
 import { MqMessageService } from 'src/services/mq-message.service';
 import { QueuesModuleOptions } from 'src/interfaces';
 import { DatabasePublisher } from 'src/services/queues/database-publisher.service';
 
 @Injectable()
-export class SmsQueuePublisherDatabase extends DatabasePublisher<any> {
+export class Msg91SmsQueuePublisherDatabase extends DatabasePublisher<any> {
     constructor(
         protected readonly mqMessageService: MqMessageService,
         protected readonly mqMessageQueueService: MqMessageQueueService,

package/src/jobs/database/{sms-subscriber-database.service.ts → msg91-sms-subscriber-database.service.ts}

@@ -1,18 +1,20 @@
 import { Injectable } from '@nestjs/common';
 
 import { QueueMessage } from 'src/interfaces/mq';
-import smsQueueOptions from './sms-queue-database-options';
+import smsQueueOptions from './msg91-sms-queue-database-options';
 import { MqMessageService } from 'src/services/mq-message.service';
 import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
 import { Msg91SMSService } from 'src/services/sms/Msg91SMSService';
 import { QueuesModuleOptions } from 'src/interfaces';
 import { DatabaseSubscriber } from 'src/services/queues/database-subscriber.service';
 import { PollerService } from 'src/services/poller.service';
+import { SmsFactory } from 'src/factories/sms.factory';
 
 @Injectable()
-export class SmsQueueSubscriberDatabase extends DatabaseSubscriber<any> {
+export class Msg91SmsQueueSubscriberDatabase extends DatabaseSubscriber<any> {
     constructor(
-        private readonly smsService: Msg91SMSService,
+        // private readonly smsService: Msg91SMSService,
+        private readonly smsFactory: SmsFactory,
         readonly mqMessageService: MqMessageService,
         readonly mqMessageQueueService: MqMessageQueueService,
         readonly poller: PollerService,
@@ -27,6 +29,9 @@ export class SmsQueueSubscriberDatabase extends DatabaseSubscriber<any> {
     }
 
     subscribe(message: QueueMessage<any>) {
-        return this.smsService.sendSMSSynchronously(message);
+        const smsService: Msg91SMSService = this.smsFactory.getSmsService(Msg91SMSService.name) as Msg91SMSService;
+        return smsService.sendSMSSynchronously(message);
+
+        // return this.smsService.sendSMSSynchronously(message);
     }
 }

package/src/jobs/database/otp-subscriber-database.service.ts

@@ -8,11 +8,14 @@ import { DatabaseSubscriber } from 'src/services/queues/database-subscriber.serv
 import { Msg91OTPService } from 'src/services/sms/Msg91OTPService';
 import { QueuesModuleOptions } from 'src/interfaces';
 import { PollerService } from 'src/services/poller.service';
+import { SmsFactory } from 'src/factories/sms.factory';
 
 @Injectable()
 export class OTPQueueSubscriberDatabase extends DatabaseSubscriber<any> {
     constructor(
-        private readonly otpService: Msg91OTPService,
+        // private readonly otpService: Msg91OTPService,
+        private readonly smsFactory: SmsFactory,
+
         readonly mqMessageService: MqMessageService,
         readonly poller: PollerService,
         readonly mqMessageQueueService: MqMessageQueueService,
@@ -27,6 +30,9 @@ export class OTPQueueSubscriberDatabase extends DatabaseSubscriber<any> {
     }
 
     subscribe(message: QueueMessage<any>) {
-        this.otpService.sendSMSSynchronously(message);
+        const otpService: Msg91OTPService = this.smsFactory.getSmsService(Msg91OTPService.name) as Msg91OTPService;
+        return otpService.sendSMSSynchronously(message);
+
+        // this.otpService.sendSMSSynchronously(message);
     }
 }

package/src/jobs/database/twilio-sms-subscriber-database.service.ts

@@ -8,11 +8,13 @@ import { QueuesModuleOptions } from 'src/interfaces';
 import { DatabaseSubscriber } from 'src/services/queues/database-subscriber.service';
 import { TwilioSMSService } from 'src/services/sms/TwilioSMSService';
 import { PollerService } from 'src/services/poller.service';
+import { SmsFactory } from 'src/factories/sms.factory';
 
 @Injectable()
 export class TwilioSmsQueueSubscriberDatabase extends DatabaseSubscriber<any> {
     constructor(
-        private readonly smsService: TwilioSMSService,
+        // private readonly smsService: TwilioSMSService,
+        private readonly smsFactory: SmsFactory,
         readonly mqMessageService: MqMessageService,
         readonly mqMessageQueueService: MqMessageQueueService,
         readonly poller: PollerService,
@@ -27,6 +29,7 @@ export class TwilioSmsQueueSubscriberDatabase extends DatabaseSubscriber<any> {
     }
 
     subscribe(message: QueueMessage<any>) {
-        return this.smsService.sendSMSSynchronously(message);
+        const smsService: TwilioSMSService = this.smsFactory.getSmsService(TwilioSMSService.name) as TwilioSMSService;
+        return smsService.sendSMSSynchronously(message);
     }
 }

package/src/jobs/{otp-publisher.service.ts → msg91-otp-publisher.service.ts}

@@ -1,13 +1,13 @@
 import { Injectable } from '@nestjs/common';
 
 import { RabbitMqPublisher } from 'src/services/queues/rabbitmq-publisher.service';
-import otpQueueOptions from './otp-queue-options';
+import otpQueueOptions from './msg91-otp-queue-options';
 import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
 import { MqMessageService } from 'src/services/mq-message.service';
 import { QueuesModuleOptions } from "../interfaces";
 
 @Injectable()
-export class OTPQueuePublisher extends RabbitMqPublisher<any> {
+export class Msg91OTPQueuePublisher extends RabbitMqPublisher<any> {
     constructor(
         protected readonly mqMessageService: MqMessageService,
         protected readonly mqMessageQueueService: MqMessageQueueService,

package/src/jobs/{otp-subscriber.service.ts → msg91-otp-subscriber.service.ts}

@@ -3,15 +3,18 @@ import { Injectable } from '@nestjs/common';
 import { QueueMessage } from 'src/interfaces/mq';
 import { RabbitMqSubscriber } from 'src/services/queues/rabbitmq-subscriber.service';
 import { Msg91OTPService } from '../services/sms/Msg91OTPService';
-import otpQueueOptions from './otp-queue-options';
+import otpQueueOptions from './msg91-otp-queue-options';
 import { MqMessageService } from 'src/services/mq-message.service';
 import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
 import { QueuesModuleOptions } from "../interfaces";
+import { SmsFactory } from 'src/factories/sms.factory';
 
 @Injectable()
-export class OTPQueueSubscriber extends RabbitMqSubscriber<any> {
+export class Msg91OTPQueueSubscriber extends RabbitMqSubscriber<any> {
     constructor(
-        private readonly otpService: Msg91OTPService,
+        // private readonly otpService: Msg91OTPService,
+        private readonly smsFactory: SmsFactory,
+
         readonly mqMessageService: MqMessageService,
         readonly mqMessageQueueService: MqMessageQueueService,
     ) {
@@ -25,6 +28,9 @@ export class OTPQueueSubscriber extends RabbitMqSubscriber<any> {
     }
 
     subscribe(message: QueueMessage<any>) {
-        this.otpService.sendSMSSynchronously(message);
+        const otpService: Msg91OTPService = this.smsFactory.getSmsService(Msg91OTPService.name) as Msg91OTPService;
+        return otpService.sendSMSSynchronously(message);
+
+        // this.otpService.sendSMSSynchronously(message);
     }
 }

package/src/jobs/{sms-publisher.service.ts → msg91-sms-publisher.service.ts}

@@ -1,13 +1,13 @@
 import { Injectable } from '@nestjs/common';
 
 import { RabbitMqPublisher } from 'src/services/queues/rabbitmq-publisher.service';
-import smsQueueOptions from './sms-queue-options';
+import smsQueueOptions from './msg91-sms-queue-options';
 import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
 import { MqMessageService } from 'src/services/mq-message.service';
 import { QueuesModuleOptions } from "../interfaces";
 
 @Injectable()
-export class SmsQueuePublisher extends RabbitMqPublisher<any> {
+export class Msg91SmsQueuePublisher extends RabbitMqPublisher<any> {
     constructor(
         protected readonly mqMessageService: MqMessageService,
         protected readonly mqMessageQueueService: MqMessageQueueService,

package/src/jobs/{sms-subscriber.service.ts → msg91-sms-subscriber.service.ts}

@@ -2,16 +2,18 @@ import { Injectable } from '@nestjs/common';
 
 import { RabbitMqSubscriber } from 'src/services/queues/rabbitmq-subscriber.service';
 import { QueueMessage } from 'src/interfaces/mq';
-import smsQueueOptions from './sms-queue-options';
+import smsQueueOptions from './msg91-sms-queue-options';
 import { Msg91SMSService } from '../services/sms/Msg91SMSService';
 import { MqMessageService } from 'src/services/mq-message.service';
 import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
 import { QueuesModuleOptions } from "../interfaces";
+import { SmsFactory } from 'src/factories/sms.factory';
 
 @Injectable()
-export class SmsQueueSubscriber extends RabbitMqSubscriber<any> {
+export class Msg91SmsQueueSubscriber extends RabbitMqSubscriber<any> {
     constructor(
-        private readonly smsService: Msg91SMSService,
+        // private readonly smsService: Msg91SMSService,
+        private readonly smsFactory: SmsFactory,
         readonly mqMessageService: MqMessageService,
         readonly mqMessageQueueService: MqMessageQueueService,
     ) {
@@ -25,6 +27,9 @@ export class SmsQueueSubscriber extends RabbitMqSubscriber<any> {
     }
 
     subscribe(message: QueueMessage<any>) {
-        return this.smsService.sendSMSSynchronously(message);
+        const smsService: Msg91SMSService = this.smsFactory.getSmsService(Msg91SMSService.name) as Msg91SMSService;
+        return smsService.sendSMSSynchronously(message);
+
+        // return this.smsService.sendSMSSynchronously(message);
     }
 }

package/src/jobs/twilio-sms-subscriber.service.ts

@@ -8,11 +8,13 @@ import { PollerService } from 'src/services/poller.service';
 import { TwilioSMSService } from 'src/services/sms/TwilioSMSService';
 import smsQueueOptions from './twilio-sms-queue-options';
 import { RabbitMqSubscriber } from 'src/services/queues/rabbitmq-subscriber.service';
+import { SmsFactory } from 'src/factories/sms.factory';
 
 @Injectable()
 export class TwilioSmsQueueSubscriberRabbitmq extends RabbitMqSubscriber<any> {
     constructor(
-        private readonly smsService: TwilioSMSService,
+        // private readonly smsService: TwilioSMSService,
+        private readonly smsFactory: SmsFactory,
         readonly mqMessageService: MqMessageService,
         readonly mqMessageQueueService: MqMessageQueueService,
         readonly poller: PollerService,
@@ -27,6 +29,8 @@ export class TwilioSmsQueueSubscriberRabbitmq extends RabbitMqSubscriber<any> {
     }
 
     subscribe(message: QueueMessage<any>) {
-        return this.smsService.sendSMSSynchronously(message);
+        const smsService: TwilioSMSService = this.smsFactory.getSmsService(TwilioSMSService.name) as TwilioSMSService;
+        return smsService.sendSMSSynchronously(message);
+        // return this.smsService.sendSMSSynchronously(message);
     }
 }

package/src/repository/media.repository.ts

@@ -1,7 +1,7 @@
-import { Injectable } from '@nestjs/common';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
 import { Media } from 'src/entities/media.entity';
 import { RequestContextService } from 'src/services/request-context.service';
-import { DataSource } from 'typeorm';
+import { DataSource, In } from 'typeorm';
 import { FieldMetadataRepository } from './field-metadata.repository';
 import { MediaStorageProviderMetadataRepository } from './media-storage-provider-metadata.repository';
 import { ModelMetadataRepository } from './model-metadata.repository';
@@ -21,6 +21,7 @@ export class MediaRepository extends SolidBaseRepository<Media> {
         // @InjectRepository(MediaStorageProviderMetadata)
         // private readonly mediaStorageProviderMetadataRepo: Repository<MediaStorageProviderMetadata>,
         private readonly fieldMetadataRepo: FieldMetadataRepository,
+        @Inject(forwardRef(() => ModelMetadataRepository))
         private readonly modelMetadataRepo: ModelMetadataRepository,
         private readonly mediaStorageProviderMetadataRepo: MediaStorageProviderMetadataRepository,
     ) {