@solidxai/core 0.1.10-beta.9 → 0.1.10

package/src/services/question-data-providers/prime-react-meter-group-sql-data-provider.service.ts

@@ -1,115 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import { DashboardQuestionDataProvider } from "src/decorators/dashboard-question-data-provider.decorator";
-import { DashboardQuestion } from "src/entities/dashboard-question.entity";
-import { IDashboardQuestionDataProvider, QuestionSqlDataProviderContext } from "src/interfaces";
-import { EntityManager } from "typeorm";
-import { SqlExpressionResolverService } from "../sql-expression-resolver.service";
-import { Logger } from '@nestjs/common';
-import { SqlExpression } from "./chartjs-sql-data-provider.service";
-import { getKpi } from "./helpers";
-
-@DashboardQuestionDataProvider()
-@Injectable()
-export class PrimeReactMeterGroupSqlDataProvider implements IDashboardQuestionDataProvider<QuestionSqlDataProviderContext, any> {
-    private readonly logger = new Logger(PrimeReactMeterGroupSqlDataProvider.name);
-
-    constructor(private readonly entityManager: EntityManager, private readonly sqlExpressionResolver: SqlExpressionResolverService) { }
-
-    help(): string {
-        return "Provides data for dashboard questions using a SQL dataset configuration. Configure your SQL dataset in the admin panel, then reference it in your dashboard question to fetch data.";
-    }
-
-    name(): string {
-        return "PrimeReactMeterGroupSqlDataProvider";
-    }
-
-    hslToHex(h: number, s: number, l: number): string {
-        l /= 100;
-        s /= 100;
-
-        const k = (n: number) => (n + h / 30) % 12;
-        const a = s * Math.min(l, 1 - l);
-        const f = (n: number) =>
-            Math.round(255 * (l - a * Math.max(-1, Math.min(k(n) - 3, Math.min(9 - k(n), 1)))));
-
-        return `#${f(0).toString(16).padStart(2, '0')}${f(8).toString(16).padStart(2, '0')}${f(4)
-            .toString(16)
-            .padStart(2, '0')}`;
-    }
-
-    generateDistinctColors(count: number): string[] {
-        const colors: string[] = [];
-
-        const hueStep = 360 / count;
-        const saturation = 65; // keep it vibrant
-        const lightness = 55;  // balanced for both light/dark themes
-
-        for (let i = 0; i < count; i++) {
-            const hue = Math.round(i * hueStep);
-            colors.push(this.hslToHex(hue, saturation, lightness));
-        }
-
-        return colors;
-    }
-
-    async getData(question: DashboardQuestion, context?: QuestionSqlDataProviderContext): Promise<any> {
-        const expressions: SqlExpression[] = context?.expressions || [];
-
-        // TODO: put some validation to check if the results of each SQL in each dataset returns the same number of rows 
-
-        // This is what we have to return.
-        // const values = [
-        //     { label: 'Apps', color: '#34d399', value: 16 },
-        //     { label: 'Messages', color: '#fbbf24', value: 8 },
-        //     { label: 'Media', color: '#60a5fa', value: 24 },
-        //     { label: 'System', color: '#c084fc', value: 10 }
-        // ];
-
-        // TODO: Load the set of labels by using a separate field on the question entity.
-
-        const kpi: string = await getKpi(question, expressions, this.entityManager, this.sqlExpressionResolver);
-        
-        // Load the chart options as a JSON 
-        const chartOptions = JSON.parse(question.chartOptions || '{}');
-
-        const values = []
-
-        // For meter group we can assume that we only have one sql dataset config.
-        const questionSqlDatasetConfig = question.questionSqlDatasetConfigs[0];
-
-        const sql = questionSqlDatasetConfig.sql;
-        if (!sql) {
-            throw new Error(`SQL dataset ${questionSqlDatasetConfig.datasetName} configuration does not contain a valid SQL query.`);
-        }
-
-        const sqlReplacementResult = this.sqlExpressionResolver.resolveSqlWithExpressions(sql, expressions || []);
-        this.logger.debug(`Final Sql query for dataset [${questionSqlDatasetConfig.datasetName}] is query=[${sqlReplacementResult.rawSql}]`);
-        this.logger.debug(`Final Sql query for dataset [${questionSqlDatasetConfig.datasetName}] is parameters=[${JSON.stringify(sqlReplacementResult.parameters)}]`);
-        const results = await this.entityManager.query(sqlReplacementResult.rawSql, sqlReplacementResult.parameters);
-
-        const colors = this.generateDistinctColors(results.length);
-
-        // Also for each data set we create the dataset object as is expected by ChartJs.
-        for (let i = 0; i < results.length; i++) {
-            const result = results[i];
-
-            const colorFromChartOptions = chartOptions?.colors?.[result[questionSqlDatasetConfig.labelColumnName]];
-            const color = typeof colorFromChartOptions === 'string' ? colorFromChartOptions : colors[i];
-
-            values.push({
-                label: result[questionSqlDatasetConfig.labelColumnName],
-                color: color,
-                value: result[questionSqlDatasetConfig.valueColumnName]
-            })
-        }
-
-        return {
-            kpi,
-            visualizedAs: question.visualisedAs,
-            visualizationData: {
-                dataset: values
-            },
-        };
-
-    }
-}

package/src/services/selection-providers/list-of-dashboard-question-providers-selection-provider.service.ts

@@ -1,44 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import { SelectionProvider } from "src/decorators/selection-provider.decorator";
-import { SolidRegistry } from "src/helpers/solid-registry";
-import { IDashboardQuestionDataProvider, IDashboardVariableSelectionProvider, ISelectionProvider, ISelectionProviderContext, ISelectionProviderValues } from "../../interfaces";
-import { SQL_DYNAMIC_PROVIDER_NAME } from "../dashboard.service";
-import { CHARTJS_SQL_DATA_PROVIDER_NAME, INBUILT_SQL_DATA_PROVIDERS, PRIME_REACT_DATATABLE_SQL_DATA_PROVIDER_NAME, PRIME_REACT_METER_GROUP_SQL_DATA_PROVIDER_NAME } from "../dashboard-question.service";
-
-
-@SelectionProvider()
-@Injectable()
-export class ListOfDashboardQuestionProvidersSelectionProvider implements ISelectionProvider<ISelectionProviderContext> {
-
-    constructor(
-        private readonly solidRegistry: SolidRegistry,
-    ) {
-    }
-
-    help(): string {
-        return "# Allows one to dynamically fetch all the dashboard providers that are registered in the system. ";
-    }
-
-    name(): string {
-        return 'ListOfDashboardQuestionProvidersSelectionProvider';
-    }
-
-    async value(optionValue: string, ctxt: ISelectionProviderContext): Promise<ISelectionProviderValues | any> {
-        const dashboardSelectionProvider: IDashboardQuestionDataProvider<any, any> | undefined = this.solidRegistry.getDashboardQuestionDataProviderInstance(optionValue);
-        if (!dashboardSelectionProvider) {
-            return null;
-        }
-
-        return { label: dashboardSelectionProvider.name(), value: dashboardSelectionProvider.name() };
-    }
-
-    async values(query: string, ctxt: ISelectionProviderContext): Promise<readonly ISelectionProviderValues[]> {
-        const dashboardSelectionProviders = this.solidRegistry.getDashboardQuestionDataProviders()
-        //Exclude the SQL dynamic provider from the list, (since although it is a dashboard selection provider, it is not a valid option for the user to select)
-        return dashboardSelectionProviders
-        .filter(provider => !INBUILT_SQL_DATA_PROVIDERS.includes(provider.name())) 
-        .map(i => {
-            return { label: i.name, value: i.name };
-        });
-    }
-}

package/src/services/selection-providers/list-of-dashboard-variable-providers-selection-provider.service.ts

@@ -1,41 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import { SelectionProvider } from "src/decorators/selection-provider.decorator";
-import { SolidRegistry } from "src/helpers/solid-registry";
-import { IDashboardVariableSelectionProvider, ISelectionProvider, ISelectionProviderContext, ISelectionProviderValues } from "../../interfaces";
-import { SQL_DYNAMIC_PROVIDER_NAME } from "../dashboard.service";
-
-
-@SelectionProvider()
-@Injectable()
-export class ListOfDashboardVariableProvidersSelectionProvider implements ISelectionProvider<ISelectionProviderContext> {
-
-    constructor(
-        private readonly solidRegistry: SolidRegistry,
-    ) {
-    }
-
-    help(): string {
-        return "# Allows one to dynamically fetch all the dashboard providers that are registered in the system. ";
-    }
-
-    name(): string {
-        return 'ListOfDashboardVariableProvidersSelectionProvider';
-    }
-
-    async value(optionValue: string, ctxt: ISelectionProviderContext): Promise<ISelectionProviderValues | any> {
-        const dashboardSelectionProvider: IDashboardVariableSelectionProvider<ISelectionProviderContext> | undefined = this.solidRegistry.getDashboardVariableSelectionProviderInstance(optionValue);
-        if (!dashboardSelectionProvider) {
-            return null;
-        }
-
-        return { label: dashboardSelectionProvider.name(), value: dashboardSelectionProvider.name() };
-    }
-
-    async values(query: string, ctxt: ISelectionProviderContext): Promise<readonly ISelectionProviderValues[]> {
-        const dashboardSelectionProviders = this.solidRegistry.getDashboardVariableSelectionProviders()
-        //Exclude the SQL dynamic provider from the list, (since although it is a dashboard selection provider, it is not a valid option for the user to select)
-        return dashboardSelectionProviders.filter(i => (i.name !== SQL_DYNAMIC_PROVIDER_NAME)).map(i => {
-            return { label: i.name, value: i.name };
-        });
-    }
-}

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

@@ -1,140 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import { SqlExpression, SqlExpressionOperator } from "./question-data-providers/chartjs-sql-data-provider.service";
-import { RequestContextService } from "./request-context.service";
-import { ERROR_MESSAGES } from "src/constants/error-messages";
-
-export interface SqlReplacementResult {
-  rawSql: string;
-  parameters: any[]; // Positional parameters
-}
-
-@Injectable()
-export class SqlExpressionResolverService {
-  constructor(private readonly requestContextService: RequestContextService) { }
-  resolveSqlWithExpressions(sql: string, expressions: SqlExpression[]): SqlReplacementResult {
-    const variableToColumnMap: Record<string, string> = {};
-    const variablePattern = /{{\s*(\w+)\s*\[\s*([\w.]+)\s*\]\s*}}/g;
-
-    let paramIndex = 1;
-    const parameters: any[] = [];
-
-    // Handle sql expression tokens like {{$activeUserId}} in the SQL string
-    if (sql.includes('{{$activeUserId}}')) {
-      const activeUser = this.requestContextService.getActiveUser();
-      if (activeUser && activeUser.sub) {
-        // Replace custom placeholder with parameter placeholder ($1)
-        sql = sql.replace(/\{\{\$activeUserId\}\}/g, `$${paramIndex++}`);
-        // Add the active user ID to parameters
-        parameters.push(activeUser.sub);
-      }
-    }
-
-    // --- 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 ---
-
-    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(ERROR_MESSAGES.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/subscribers/dashboard-question-sql-dataset-config.subscriber.ts

@@ -1,61 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,62 +0,0 @@
-import { Injectable, Logger } from '@nestjs/common';
-import { InjectDataSource } from "@nestjs/typeorm";
-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 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.saveDashboardToConfig(event.entity, event.queryRunner.manager);
-    }
-
-    async afterUpdate(event: UpdateEvent<Dashboard>) {
-        if (!event.entity) {
-            this.logger.debug('No dashboard entity found in the DashboardSubscriber afterInsert method');
-            return;
-        }
-
-        await this.saveDashboardToConfig(event.databaseEntity, event.queryRunner.manager);
-    }
-
-    private async saveDashboardToConfig(dashboard: Dashboard, entityManager: EntityManager): Promise<void> {
-        if (!dashboard || !dashboard.id) {
-            this.logger.debug('Dashboard or dashboard id is undefined');
-            return;
-        }
-
-        // Load the dashboard with module relation populated
-        const populatedDashboard = await entityManager.findOne(Dashboard, {
-            where: { id: dashboard.id },
-            relations: ['module','dashboardVariables', 'questions', 'questions.questionSqlDatasetConfigs'],
-        });
-
-        if (!populatedDashboard) {
-            this.logger.error(`Dashboard not found for id ${dashboard.id}`);
-            return;
-        }
-
-        // Call the saveDashboardToConfig method from the DashboardService
-        await this.dashboardService.saveDashboardToConfig(populatedDashboard);
-    }
-
-}