@solidstarters/solid-core 1.2.134 → 1.2.136

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

@@ -8,6 +8,8 @@ import { IS_SOLID_DATABASE_MODULE } from 'src/decorators/solid-database-module.d
 import { SolidRegistry } from 'src/helpers/solid-registry';
 import { CRUDService } from './crud.service';
 import { IS_SCHEDULED_JOB_PROVIDER } from 'src/decorators/scheduled-job-provider.decorator';
+import { IS_DASHBOARD_VARIABLE_SELECTION_PROVIDER } from 'src/decorators/dashboard-selection-provider.decorator';
+import { IS_DASHBOARD_QUESTION_DATA_PROVIDER } from 'src/decorators/dashboard-question-data-provider.decorator';
 
 @Injectable()
 export class SolidIntrospectService implements OnApplicationBootstrap {
@@ -42,6 +44,26 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
       this.solidRegistry.registerSelectionProvider(selectionProvider);
     });
 
+    // Register all IDashboardSelectionProvider implementations
+    const dashboardVariableSelectionProviders = this.discoveryService
+      .getProviders()
+      .filter((provider) => this.isDashboardVariableSelectionProvider(provider));
+
+    dashboardVariableSelectionProviders.forEach((dashboardSelectionProvider) => {
+      // @ts-ignore
+      this.solidRegistry.registerDashboardVariableSelectionProvider(dashboardSelectionProvider);
+    });
+
+    // Register all IDashboardSelectionProvider implementations
+    const dashboardQuestionDataProviders = this.discoveryService
+      .getProviders()
+      .filter((provider) => this.isDashboardQuestionDataProvider(provider));
+
+    dashboardQuestionDataProviders.forEach((provider) => {
+      // @ts-ignore
+      this.solidRegistry.registerDashboardQuestionDataProvider(provider);
+    });
+
 
     // Register all IComputedProvider implementations
     const computedFieldProviders = this.discoveryService
@@ -94,6 +116,16 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
 
   }
 
+  isDashboardQuestionDataProvider(providerWrapper: InstanceWrapper<any>) {
+    const { instance } = providerWrapper;
+    if (!instance) return false;
+    const provider = this.reflector.get<boolean>(
+      IS_DASHBOARD_QUESTION_DATA_PROVIDER,
+      instance.constructor,
+    );
+    return !!provider;
+  }
+
   // This method identifies a provider as a seeder if it has a seed method i.e duck typing
   private isSeeder(provider: InstanceWrapper) {
     const { instance } = provider;
@@ -118,6 +150,16 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
     return !!isSelectionProvider;
   }
 
+  private isDashboardVariableSelectionProvider(provider: InstanceWrapper) {
+    const { instance } = provider;
+    if (!instance) return false;
+    const isDashboardSelectionProvider = this.reflector.get<boolean>(
+      IS_DASHBOARD_VARIABLE_SELECTION_PROVIDER,
+      instance.constructor,
+    );
+    return !!isDashboardSelectionProvider;
+  }
+
   private isComputedFieldProvider(provider: InstanceWrapper) {
     const { instance } = provider;
     if (!instance) return false;

package/src/services/sql-expression-resolver.service.ts

@@ -0,0 +1,125 @@
+import { Injectable } from "@nestjs/common";
+import { SqlExpression, SqlExpressionOperator } from "./question-data-providers/chartjs-sql-data-provider.service";
+
+export interface SqlReplacementResult {
+  rawSql: string;
+  parameters: any[]; // Positional parameters
+}
+
+@Injectable()
+export class SqlExpressionResolverService {
+  resolveSqlWithExpressions(sql: string, expressions: SqlExpression[]): SqlReplacementResult {
+    const variableToColumnMap: Record<string, string> = {};
+    const variablePattern = /{{\s*(\w+)\s*\[\s*([\w.]+)\s*\]\s*}}/g;
+
+    // --- Pass 1: extract variable -> column mappings ---
+    let simplifiedSql = sql.replace(variablePattern, (_, variableName, columnName) => {
+      variableToColumnMap[variableName] = columnName;
+      return `{{${variableName}}}`;
+    });
+
+    // --- Pass 2: Replace each variable with positional fragment ---
+    let paramIndex = 1;
+    const parameters: any[] = [];
+
+    for (const expr of expressions) {
+      const column = variableToColumnMap[expr.variableName];
+      if (!column) continue;
+
+      let sqlFragment = '';
+      const placeholder = `{{${expr.variableName}}}`;
+
+      switch (expr.operator) {
+        case SqlExpressionOperator.EQUALS:
+          sqlFragment = `${column} = $${paramIndex++}`;
+          parameters.push(expr.value[0]);
+          break;
+
+        case SqlExpressionOperator.NOT_EQUALS:
+          sqlFragment = `${column} != $${paramIndex++}`;
+          parameters.push(expr.value[0]);
+          break;
+
+        case SqlExpressionOperator.CONTAINS:
+          sqlFragment = `${column} LIKE $${paramIndex++}`;
+          parameters.push(`%${expr.value[0]}%`);
+          break;
+
+        case SqlExpressionOperator.NOT_CONTAINS:
+          sqlFragment = `${column} NOT LIKE $${paramIndex++}`;
+          parameters.push(`%${expr.value[0]}%`);
+          break;
+
+        case SqlExpressionOperator.STARTS_WITH:
+          sqlFragment = `${column} LIKE $${paramIndex++}`;
+          parameters.push(`${expr.value[0]}%`);
+          break;
+
+        case SqlExpressionOperator.ENDS_WITH:
+          sqlFragment = `${column} LIKE $${paramIndex++}`;
+          parameters.push(`%${expr.value[0]}`);
+          break;
+
+        case SqlExpressionOperator.IN:
+          const inParams = expr.value.map(val => {
+            parameters.push(val);
+            return `$${paramIndex++}`;
+          });
+          sqlFragment = `${column} IN (${inParams.join(", ")})`;
+          break;
+
+        case SqlExpressionOperator.NOT_IN:
+          const notInParams = expr.value.map(val => {
+            parameters.push(val);
+            return `$${paramIndex++}`;
+          });
+          sqlFragment = `${column} NOT IN (${notInParams.join(", ")})`;
+          break;
+
+        case SqlExpressionOperator.BETWEEN:
+          sqlFragment = `${column} BETWEEN $${paramIndex} AND $${paramIndex + 1}`;
+          parameters.push(expr.value[0], expr.value[1]);
+          paramIndex += 2;
+          break;
+
+        case SqlExpressionOperator.LT:
+          sqlFragment = `${column} < $${paramIndex++}`;
+          parameters.push(expr.value[0]);
+          break;
+
+        case SqlExpressionOperator.LTE:
+          sqlFragment = `${column} <= $${paramIndex++}`;
+          parameters.push(expr.value[0]);
+          break;
+
+        case SqlExpressionOperator.GT:
+          sqlFragment = `${column} > $${paramIndex++}`;
+          parameters.push(expr.value[0]);
+          break;
+
+        case SqlExpressionOperator.GTE:
+          sqlFragment = `${column} >= $${paramIndex++}`;
+          parameters.push(expr.value[0]);
+          break;
+
+        default:
+          throw new Error(`Unsupported SQL operator: ${expr.operator}`);
+      }
+      simplifiedSql = simplifiedSql.replace(placeholder, sqlFragment);
+    }
+
+    // --- Final cleanup: remove any remaining placeholders ---
+    simplifiedSql = simplifiedSql.replace(/{{\s*\w+\s*}}/g, '');
+
+    // Remove dangling where clause if no expressions were applied
+    simplifiedSql = simplifiedSql.replace(/\bwhere\b\s*$/i, '').trim();
+
+    // Need to handle scenarios of complex expression i.e with and / or clauses. probably need to have this logic in the sql expression object itself
+
+
+    return {
+      rawSql: simplifiedSql,
+      parameters
+    };
+  }
+}

package/src/solid-core.module.ts

@@ -128,9 +128,15 @@ import { PermissionMetadataController } from './controllers/permission-metadata.
 import { PermissionMetadata } from './entities/permission-metadata.entity';
 import { PermissionMetadataService } from './services/permission-metadata.service';
 
+import { ScheduleModule } from '@nestjs/schedule';
 import { ClsModule } from 'nestjs-cls';
+import { AiInteractionController } from './controllers/ai-interaction.controller';
 import { ChatterMessageDetailsController } from './controllers/chatter-message-details.controller';
 import { ChatterMessageController } from './controllers/chatter-message.controller';
+import { DashboardQuestionSqlDatasetConfigController } from './controllers/dashboard-question-sql-dataset-config.controller';
+import { DashboardQuestionController } from './controllers/dashboard-question.controller';
+import { DashboardVariableController } from './controllers/dashboard-variable.controller';
+import { DashboardController } from './controllers/dashboard.controller';
 import { ExportTemplateController } from './controllers/export-template.controller';
 import { ExportTransactionController } from './controllers/export-transaction.controller';
 import { ImportTransactionErrorLogController } from './controllers/import-transaction-error-log.controller';
@@ -145,8 +151,13 @@ import { SettingController } from './controllers/setting.controller';
 import { UserActivityHistoryController } from './controllers/user-activity-history.controller';
 import { UserViewMetadataController } from './controllers/user-view-metadata.controller';
 import { UserController } from './controllers/user.controller';
+import { AiInteraction } from './entities/ai-interaction.entity';
 import { ChatterMessageDetails } from './entities/chatter-message-details.entity';
 import { ChatterMessage } from './entities/chatter-message.entity';
+import { DashboardQuestionSqlDatasetConfig } from './entities/dashboard-question-sql-dataset-config.entity';
+import { DashboardQuestion } from './entities/dashboard-question.entity';
+import { DashboardVariable } from './entities/dashboard-variable.entity';
+import { Dashboard } from './entities/dashboard.entity';
 import { ExportTemplate } from './entities/export-template.entity';
 import { ExportTransaction } from './entities/export-transaction.entity';
 import { ImportTransactionErrorLog } from './entities/import-transaction-error-log.entity';
@@ -160,6 +171,7 @@ import { Setting } from './entities/setting.entity';
 import { UserActivityHistory } from './entities/user-activity-history.entity';
 import { UserViewMetadata } from './entities/user-view-metadata.entity';
 import { User } from './entities/user.entity';
+import { HttpExceptionFilter } from './filters/http-exception.filter';
 import { ModelMetadataHelperService } from './helpers/model-metadata-helper.service';
 import { ModuleMetadataHelperService } from './helpers/module-metadata-helper.service';
 import { ApiEmailQueuePublisherDatabase } from './jobs/database/api-email-publisher-database.service';
@@ -174,19 +186,30 @@ 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 { 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';
 import { WhatsappQueueSubscriberDatabase } from './jobs/database/whatsapp-subscriber-database.service';
+import { DashboardMapper } from './mappers/dashboard-mapper';
+import { DashboardRepository } from './repository/dashboard.repository';
 import { FieldMetadataRepository } from './repository/field-metadata.repository';
 import { FieldRepository } from './repository/field.repository';
 import { MediaRepository } from './repository/media.repository';
 import { SecurityRuleRepository } from './repository/security-rule.repository';
 import { PermissionMetadataSeederService } from './seeders/permission-metadata-seeder.service';
 import { SystemFieldsSeederService } from './seeders/system-fields-seeder.service';
+import { AiInteractionService } from './services/ai-interaction.service';
 import { ChatterMessageDetailsService } from './services/chatter-message-details.service';
 import { ChatterMessageService } from './services/chatter-message.service';
 import { ConcatComputedFieldProvider } from './services/computed-fields/concat-computed-field-provider.service';
 import { ConcatEntityComputedFieldProvider } from './services/computed-fields/entity/concat-entity-computed-field-provider.service';
 import { CsvService } from './services/csv.service';
+import { DashboardQuestionSqlDatasetConfigService } from './services/dashboard-question-sql-dataset-config.service';
+import { DashboardQuestionService } from './services/dashboard-question.service';
+import { DashboardVariableSQLDynamicProvider } from './services/dashboard-selection-providers/dashboard-variable-sql-dynamic-provider.service';
+import { DasbhoardVariableTestDynamicProvider } from './services/dashboard-selection-providers/dashboard-variable-test-dynamic-provider.service';
+import { DashboardVariableService } from './services/dashboard-variable.service';
+import { DashboardService } from './services/dashboard.service';
 import { ExcelService } from './services/excel.service';
 import { ExportTemplateService } from './services/export-template.service';
 import { ExportTransactionService } from './services/export-transaction.service';
@@ -195,6 +218,9 @@ import { ImportTransactionService } from './services/import-transaction.service'
 import { LocaleService } from './services/locale.service';
 import { FileS3StorageProvider } from './services/mediaStorageProviders/file-s3-storage-provider';
 import { FileStorageProvider } from './services/mediaStorageProviders/file-storage-provider';
+import { ChartJsSqlDataProvider } from './services/question-data-providers/chartjs-sql-data-provider.service';
+import { PrimeReactDatatableSqlDataProvider } from './services/question-data-providers/prime-react-datatable-sql-data-provider.service';
+import { PrimeReactMeterGroupSqlDataProvider } from './services/question-data-providers/prime-react-meter-group-sql-data-provider.service';
 import { PublisherFactory } from './services/queues/publisher-factory.service';
 import { RequestContextService } from './services/request-context.service';
 import { RoleMetadataService } from './services/role-metadata.service';
@@ -202,18 +228,25 @@ import { SavedFiltersService } from './services/saved-filters.service';
 import { ScheduledJobService } from './services/scheduled-job.service';
 import { SchedulerServiceImpl } from './services/scheduled-jobs/scheduler.service';
 import { SecurityRuleService } from './services/security-rule.service';
+import { ListOfDashboardQuestionProvidersSelectionProvider } from './services/selection-providers/list-of-dashboard-question-providers-selection-provider.service';
+import { ListOfDashboardVariableProvidersSelectionProvider } from './services/selection-providers/list-of-dashboard-variable-providers-selection-provider.service';
 import { ListOfScheduledJobsSelectionProvider } from './services/selection-providers/list-of-scheduled-jobs-selection-provider.service';
 import { LocaleListSelectionProvider } from './services/selection-providers/locale-list-selection-provider.service';
 import { SettingService } from './services/setting.service';
+import { SqlExpressionResolverService } from './services/sql-expression-resolver.service';
 import { UserActivityHistoryService } from './services/user-activity-history.service';
 import { UserViewMetadataService } from './services/user-view-metadata.service';
 import { UserService } from './services/user.service';
 import { AuditSubscriber } from './subscribers/audit.subscriber';
 import { ComputedEntityFieldSubscriber } from './subscribers/computed-entity-field.subscriber';
 import { CreatedByUpdatedBySubscriber } from './subscribers/created-by-updated-by.subscriber';
+import { DashboardQuestionSqlDatasetConfigSubscriber } from './subscribers/dashboard-question-sql-dataset-config.subscriber';
+import { DashboardQuestionSubscriber } from './subscribers/dashboard-question.subscriber';
+import { DashboardVariableSubscriber } from './subscribers/dashboard-variable.subscriber';
+import { DashboardSubscriber } from './subscribers/dashboard.subscriber';
 import { SecurityRuleSubscriber } from './subscribers/security-rule.subscriber';
 import { ViewMetadataSubsciber } from './subscribers/view-metadata.subscriber';
-import { HttpExceptionFilter } from './filters/http-exception.filter';
+import { CRUDService } from './services/crud.service';
 
 
 @Global()
@@ -252,12 +285,14 @@ import { HttpExceptionFilter } from './filters/http-exception.filter';
       ImportTransaction,
       ImportTransactionErrorLog,
       UserActivityHistory,
+      AiInteraction,
     ]),
     ConfigModule.forFeature(appBuilderConfig),
     ConfigModule.forFeature(commonConfig),
     ConfigModule.forFeature(iamConfig),
     ConfigModule.forFeature(jwtConfig),
     JwtModule.registerAsync(jwtConfig.asProvider()),
+    ScheduleModule.forRoot(),
     ServeStaticModule.forRoot({
       rootPath: join(process.cwd(), 'media-files-storage'),
       serveRoot: '/media-files-storage',
@@ -272,6 +307,11 @@ import { HttpExceptionFilter } from './filters/http-exception.filter';
     HttpModule,
     ConfigModule,
     ClsModule,
+    TypeOrmModule.forFeature([Dashboard]),
+    TypeOrmModule.forFeature([DashboardVariable]),
+    TypeOrmModule.forFeature([DashboardQuestion]),
+    TypeOrmModule.forFeature([DashboardQuestionSqlDatasetConfig]),
+    TypeOrmModule.forFeature([AiInteraction]),
   ],
   controllers: [
     ModuleMetadataController,
@@ -310,6 +350,11 @@ import { HttpExceptionFilter } from './filters/http-exception.filter';
     ImportTransactionController,
     ImportTransactionErrorLogController,
     UserActivityHistoryController,
+    DashboardController,
+    DashboardVariableController,
+    DashboardQuestionController,
+    DashboardQuestionSqlDatasetConfigController,
+    AiInteractionController,
   ],
   providers: [
     {
@@ -343,6 +388,7 @@ import { HttpExceptionFilter } from './filters/http-exception.filter';
     SolidIntrospectService,
     DiscoveryService,
     CrudHelperService,
+    CRUDService,
     Reflector,
     MetadataScanner,
     CommandService,
@@ -371,6 +417,10 @@ import { HttpExceptionFilter } from './filters/http-exception.filter';
     SmsTemplateService,
     EmailTemplateService,
     PublisherFactory,
+
+    TriggerMcpClientPublisherDatabase,
+    TriggerMcpClientSubscriberDatabase,
+
     EmailQueuePublisher,
     EmailQueueSubscriber,
     EmailQueuePublisherDatabase,
@@ -454,7 +504,25 @@ import { HttpExceptionFilter } from './filters/http-exception.filter';
     ComputedFieldEvaluationSubscriber,
     ConcatEntityComputedFieldProvider,
     UserActivityHistoryService,
-    
+    DashboardService,
+    DashboardVariableService,
+    DashboardQuestionService,
+    DashboardVariableSQLDynamicProvider,
+    DasbhoardVariableTestDynamicProvider,
+    ListOfDashboardVariableProvidersSelectionProvider,
+    ListOfDashboardQuestionProvidersSelectionProvider,
+    DashboardQuestionSqlDatasetConfigService,
+    ChartJsSqlDataProvider,
+    PrimeReactMeterGroupSqlDataProvider,
+    PrimeReactDatatableSqlDataProvider,
+    SqlExpressionResolverService,
+    AiInteractionService,
+    DashboardMapper,
+    DashboardRepository,
+    DashboardSubscriber,
+    DashboardVariableSubscriber,
+    DashboardQuestionSubscriber,
+    DashboardQuestionSqlDatasetConfigSubscriber,
   ],
   exports: [
     ModuleMetadataService,
@@ -464,6 +532,7 @@ import { HttpExceptionFilter } from './filters/http-exception.filter';
     MediaService,
     DiscoveryService,
     CrudHelperService,
+    CRUDService,
     MulterModule,
     FileService,
     SolidRegistry,
@@ -487,6 +556,12 @@ import { HttpExceptionFilter } from './filters/http-exception.filter';
     FieldRepository,
     SchedulerServiceImpl,
     UserActivityHistoryService,
+    CsvService,
+    ExcelService,
+    SolidIntrospectService,
+    ImportTransactionService,
+    HttpModule,
+    ListOfValuesService
   ],
 })
 export class SolidCoreModule { }

package/src/subscribers/dashboard-question-sql-dataset-config.subscriber.ts

@@ -0,0 +1,61 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { InjectDataSource } from "@nestjs/typeorm";
+import { DashboardQuestionSqlDatasetConfig } from "src/entities/dashboard-question-sql-dataset-config.entity";
+import { DashboardQuestion } from "src/entities/dashboard-question.entity";
+import { ModuleMetadataHelperService } from "src/helpers/module-metadata-helper.service";
+import { DashboardService } from "src/services/dashboard.service";
+import { DataSource, EntityManager, EntitySubscriberInterface, InsertEvent, UpdateEvent } from "typeorm";
+
+@Injectable()
+export class DashboardQuestionSqlDatasetConfigSubscriber implements EntitySubscriberInterface<DashboardQuestionSqlDatasetConfig> {
+    private readonly logger = new Logger(this.constructor.name);
+    constructor(
+        @InjectDataSource()
+        private readonly dataSource: DataSource,
+        readonly moduleMetadataHelperService: ModuleMetadataHelperService,
+        readonly dashboardService: DashboardService, // Assuming you have a DashboardService for custom queries
+    ) {
+        this.dataSource.subscribers.push(this);
+    }
+
+    listenTo() {
+        return DashboardQuestionSqlDatasetConfig;
+    }
+
+    async afterInsert(event: InsertEvent<DashboardQuestionSqlDatasetConfig>) {
+        const question = event.entity.question;
+        if (!question) {
+            this.logger.debug('No question found in the QuestionSqlDatasetConfigSubscriber afterInsert method');
+            return;
+        }
+        await this.saveQuestionToConfig(question, event.queryRunner.manager);
+    }
+
+    async afterUpdate(event: UpdateEvent<DashboardQuestionSqlDatasetConfig>) {
+        const question = event.databaseEntity.question;
+        if (!question) {
+            this.logger.debug('No question found in the QuestionSqlDatasetConfigSubscriber afterUpdate method');
+            return;
+        }
+        await this.saveQuestionToConfig(question, event.queryRunner.manager);
+    }
+
+    private async saveQuestionToConfig(question: DashboardQuestion, entityManager: EntityManager): Promise<void> {
+        // Populate the dashboard for the question
+        const populatedQuestion = await entityManager.findOne(DashboardQuestion, {
+            where: {
+                id: question.id,
+            },
+            relations: ['dashboard', 'dashboard.module', 'dashboard.dashboardVariables', 'dashboard.questions', 'dashboard.questions.questionSqlDatasetConfigs'],
+        });
+        const dashboard = populatedQuestion?.dashboard;
+
+        if (!dashboard) {
+            throw new Error(`Dashboard not found for question id ${question.id}`);
+        }
+
+        // Call the saveDashboardToConfig method from the DashboardService
+        await this.dashboardService.saveDashboardToConfig(dashboard);
+    }
+
+}

package/src/subscribers/dashboard-question.subscriber.ts

@@ -0,0 +1,62 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { InjectDataSource } from "@nestjs/typeorm";
+import { DashboardQuestion } from "src/entities/dashboard-question.entity";
+import { Dashboard } from "src/entities/dashboard.entity";
+import { ModuleMetadataHelperService } from "src/helpers/module-metadata-helper.service";
+import { DashboardService } from "src/services/dashboard.service";
+import { DataSource, EntityManager, EntitySubscriberInterface, InsertEvent, UpdateEvent } from "typeorm";
+
+@Injectable()
+export class DashboardQuestionSubscriber implements EntitySubscriberInterface<DashboardQuestion> {
+    private readonly logger = new Logger(this.constructor.name);
+    constructor(
+        @InjectDataSource()
+        private readonly dataSource: DataSource,
+        readonly moduleMetadataHelperService: ModuleMetadataHelperService,
+        readonly dashboardService: DashboardService,
+    ) {
+        this.dataSource.subscribers.push(this);
+    }
+
+    listenTo() {
+        return DashboardQuestion;
+    }
+
+    async afterInsert(event: InsertEvent<DashboardQuestion>) {
+        if (!event.entity) {
+            this.logger.debug('No question entity found in the QuestionSubscriber afterInsert method');
+            return;
+        }
+        await this.saveDashboardToConfig(event.entity, event.queryRunner.manager);
+    }
+
+    async afterUpdate(event: UpdateEvent<DashboardQuestion>) {
+        if (!event.databaseEntity) {
+            this.logger.debug('No question entity found in the QuestionSubscriber afterUpdate method');
+            return;
+        }
+        await this.saveDashboardToConfig(event.databaseEntity, event.queryRunner.manager);
+    }
+
+    private async saveDashboardToConfig(question: DashboardQuestion, entityManager: EntityManager): Promise<void> {
+        const dashboard = question.dashboard;
+        // Get the dashboard from the question & call the saveDashboardToConfig method
+        if (!dashboard) {
+            this.logger.debug(`Dashboard is undefined for question id ${question.id}`);
+            return;
+        }
+
+        // populate the dashboard with its variables
+        const populatedDashboard = await entityManager.findOne(Dashboard, {
+            where: { id: dashboard.id },
+            relations: ['module','dashboardVariables', 'questions', 'questions.questionSqlDatasetConfigs'],
+        });
+
+        if (!populatedDashboard) {
+            throw new Error(`Dashboard not found for question id ${populatedDashboard.id}`);
+        }
+
+        // Call the saveDashboardToConfig method from the DashboardService
+        await this.dashboardService.saveDashboardToConfig(populatedDashboard);
+    }
+}

package/src/subscribers/dashboard-variable.subscriber.ts

@@ -0,0 +1,63 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { InjectDataSource } from "@nestjs/typeorm";
+import { DashboardVariable } from "src/entities/dashboard-variable.entity";
+import { Dashboard } from "src/entities/dashboard.entity";
+import { ModuleMetadataHelperService } from "src/helpers/module-metadata-helper.service";
+import { DashboardVariableService } from "src/services/dashboard-variable.service";
+import { DashboardService } from "src/services/dashboard.service";
+import { EntitySubscriberInterface, DataSource, InsertEvent, UpdateEvent, EntityManager } from "typeorm";
+
+@Injectable()
+export class DashboardVariableSubscriber implements EntitySubscriberInterface<DashboardVariable> {
+    private readonly logger = new Logger(this.constructor.name);
+    constructor(
+        @InjectDataSource()
+        private readonly dataSource: DataSource,
+        readonly moduleMetadataHelperService: ModuleMetadataHelperService,
+        readonly dashboardService: DashboardService, // Assuming you have a DashboardService for custom queries
+    ) {
+        this.dataSource.subscribers.push(this);
+    }
+
+    listenTo() {
+        return DashboardVariable;
+    }
+
+    async afterInsert(event: InsertEvent<DashboardVariable>) {
+        if (!event.entity) {
+            this.logger.debug('No dashboard variable entity found in the DashboardVariableSubscriber afterInsert method');
+            return;
+        }
+        await this.saveDashboardToConfig(event.entity, event.queryRunner.manager);
+    }
+
+    async afterUpdate(event: UpdateEvent<DashboardVariable>) {
+        if (!event.databaseEntity) {
+            this.logger.debug('No dashboard variable entity found in the DashboardVariableSubscriber afterUpdate method');
+            return;
+        }
+        await this.saveDashboardToConfig(event.databaseEntity, event.queryRunner.manager);
+    }
+
+    private async saveDashboardToConfig(dashboardVariable: DashboardVariable, entityManager: EntityManager): Promise<void> {
+        const dashboard = dashboardVariable.dashboard;
+        // Get the dashboard from the question & call the saveDashboardToConfig method
+        if (!dashboard) {
+            this.logger.debug(`Dashboard is undefined for dashboard variable id ${dashboardVariable.id}`);
+            return;
+        }
+
+        // populate the dashboard with its variables
+        const populatedDashboard = await entityManager.findOne(Dashboard, {
+            where: { id: dashboard.id },
+            relations: ['module','dashboardVariables', 'questions', 'questions.questionSqlDatasetConfigs'],
+        });
+
+        if (!populatedDashboard) {
+            throw new Error(`Dashboard not found for question id ${populatedDashboard.id}`);
+        }
+
+        // Call the saveDashboardToConfig method from the DashboardService
+        await this.dashboardService.saveDashboardToConfig(populatedDashboard);
+    }
+}

package/src/subscribers/dashboard.subscriber.ts

@@ -0,0 +1,43 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { InjectDataSource } from "@nestjs/typeorm";
+import * as fs from 'fs/promises'; // Use the Promise-based version of fs for async/await
+import { Dashboard } from 'src/entities/dashboard.entity';
+import { ModuleMetadataHelperService } from "src/helpers/module-metadata-helper.service";
+import { DashboardMapper } from 'src/mappers/dashboard-mapper';
+import { DashboardService } from 'src/services/dashboard.service';
+import { DataSource, EntitySubscriberInterface, InsertEvent, UpdateEvent } from "typeorm";
+
+@Injectable()
+export class DashboardSubscriber implements EntitySubscriberInterface<Dashboard> {
+    private readonly logger = new Logger(this.constructor.name);
+    constructor(
+        @InjectDataSource()
+        private readonly dataSource: DataSource,
+        readonly moduleMetadataHelperService: ModuleMetadataHelperService,
+        readonly dashboardService: DashboardService, // Assuming you have a DashboardService for custom queries
+    ) {
+        this.dataSource.subscribers.push(this);
+    }
+
+    listenTo() {
+        return Dashboard;
+    }
+
+    async afterInsert(event: InsertEvent<Dashboard>) {
+        if (!event.entity) {
+            this.logger.debug('No dashboard entity found in the DashboardSubscriber afterInsert method');
+            return;
+        }
+        await this.dashboardService.saveDashboardToConfig(event.entity);
+    }
+
+    async afterUpdate(event: UpdateEvent<Dashboard>) {
+        if (!event.entity) {
+            this.logger.debug('No dashboard entity found in the DashboardSubscriber afterInsert method');
+            return;
+        }
+
+        await this.dashboardService.saveDashboardToConfig(event.databaseEntity);
+    }
+
+}