@solidstarters/solid-core 1.2.133 → 1.2.135

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

@@ -0,0 +1,110 @@
+import { Injectable } from "@nestjs/common";
+import { DashboardQuestionDataProvider } from "src/decorators/dashboard-question-data-provider.decorator";
+import { Question } from "src/entities/question.entity";
+import { IDashboardQuestionDataProvider } 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";
+
+export interface QuestionSqlDataProviderContext {
+    // questionSqlDatasetConfig: QuestionSqlDatasetConfig;
+    // questionId: number;
+    // question: Question;
+}
+
+@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: Question, expressions?: SqlExpression[], context?: QuestionSqlDataProviderContext): Promise<any> {
+        // 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.
+
+        // 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.log(`Final Sql query for dataset [${questionSqlDatasetConfig.datasetName}] is query=[${sqlReplacementResult.rawSql}]`);
+        this.logger.log(`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 values;
+
+    }
+}

package/src/services/question-sql-dataset-config.service.ts

@@ -0,0 +1,34 @@
+import { Injectable } from '@nestjs/common';
+import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
+import { DiscoveryService, ModuleRef  } from "@nestjs/core";
+import { EntityManager, Repository } from 'typeorm';
+
+import { 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 { QuestionSqlDatasetConfig } from '../entities/question-sql-dataset-config.entity';
+
+@Injectable()
+export class QuestionSqlDatasetConfigService extends CRUDService<QuestionSqlDatasetConfig>{
+  constructor(
+    readonly modelMetadataService: ModelMetadataService,
+    readonly moduleMetadataService: ModuleMetadataService,
+    readonly configService: ConfigService,
+    readonly fileService: FileService,
+    readonly discoveryService: DiscoveryService,
+    readonly crudHelperService: CrudHelperService,
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    @InjectRepository(QuestionSqlDatasetConfig, 'default')
+    readonly repo: Repository<QuestionSqlDatasetConfig>,
+    readonly moduleRef: ModuleRef
+
+ ) {
+   super(modelMetadataService, moduleMetadataService,  configService, fileService,  discoveryService, crudHelperService,entityManager, repo, 'questionSqlDatasetConfig', 'solid-core', moduleRef);
+ }
+}

package/src/services/question.service.ts

@@ -0,0 +1,115 @@
+import { BadRequestException, Injectable, Logger, NotImplementedException } from '@nestjs/common';
+import { DiscoveryService, ModuleRef } from "@nestjs/core";
+import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
+import { EntityManager, Repository } from 'typeorm';
+
+import { ConfigService } from '@nestjs/config';
+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 { DashboardVariable } from 'src/entities/dashboard-variable.entity';
+import { SolidRegistry } from 'src/helpers/solid-registry';
+import { Question } from '../entities/question.entity';
+import { SqlExpression, SqlExpressionOperator } from './question-data-providers/chartjs-sql-data-provider.service';
+import { DashboardService } from './dashboard.service';
+import { Dashboard } from 'src/entities/dashboard.entity';
+
+enum SOURCE_TYPE {
+  SQL = 'sql',
+  PROVIDER = 'provider',
+}
+
+const CHARTJS_SQL_DATA_PROVIDER_NAME = 'ChartJsSqlDataProvider';
+const PRIME_REACT_METER_GROUP_SQL_DATA_PROVIDER_NAME = 'PrimeReactMeterGroupSqlDataProvider';
+const PRIME_REACT_DATATABLE_SQL_DATA_PROVIDER_NAME = 'PrimeReactDatatableSqlDataProvider';
+
+@Injectable()
+export class QuestionService extends CRUDService<Question> {
+  private readonly logger = new Logger(this.constructor.name);
+  constructor(
+    readonly modelMetadataService: ModelMetadataService,
+    readonly moduleMetadataService: ModuleMetadataService,
+    readonly configService: ConfigService,
+    readonly fileService: FileService,
+    readonly discoveryService: DiscoveryService,
+    readonly crudHelperService: CrudHelperService,
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    @InjectRepository(Question, 'default')
+    readonly repo: Repository<Question>,
+    readonly moduleRef: ModuleRef,
+    readonly solidRegistry: SolidRegistry, // Assuming solidRegistry is injected for data providers
+  ) {
+    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'question', 'solid-core', moduleRef);
+  }
+
+  // Get the data for a specific question 
+  async getData(id: number, inputExpressions: SqlExpression[] = [], isPreview = false): Promise<any> {
+    // Load the question
+    const question = await this.loadQuestion(id);
+    if (!question) {
+      throw new BadRequestException(`Question with id ${id} not found`);
+    }
+
+    // Get the dashbbard variables from the question
+    const dashboardVariables = question.dashboard?.dashboardVariables || [];
+    const expressions: SqlExpression[] = this.getExpressions(isPreview, dashboardVariables, inputExpressions);
+
+    // Try to resolve the dataProvider based on a combination of sourceType and visualisedAs
+    let dataProvider = null;
+
+    if (question.sourceType === SOURCE_TYPE.SQL && ['bar', 'pie', 'line', 'donut'].includes(question.visualisedAs)) {
+      dataProvider = this.solidRegistry.getDashboardQuestionDataProviderInstance(CHARTJS_SQL_DATA_PROVIDER_NAME);
+    }
+    if (question.sourceType === SOURCE_TYPE.SQL && ['prime-meter-group'].includes(question.visualisedAs)) {
+      dataProvider = this.solidRegistry.getDashboardQuestionDataProviderInstance(PRIME_REACT_METER_GROUP_SQL_DATA_PROVIDER_NAME);
+    }
+    if (question.sourceType === SOURCE_TYPE.SQL && ['prime-datatable'].includes(question.visualisedAs)) {
+      dataProvider = this.solidRegistry.getDashboardQuestionDataProviderInstance(PRIME_REACT_DATATABLE_SQL_DATA_PROVIDER_NAME);
+    }
+
+    if (!dataProvider) {
+      throw new NotImplementedException(`Invalid data source type ${question.sourceType}`);
+    }
+
+    return await dataProvider.getData(question, expressions);
+
+  }
+
+  private getExpressions(isPreview: boolean, dashboardVariables: DashboardVariable[], inputExpressions: SqlExpression[]) {
+    const expressions: SqlExpression[] = [];
+    if (isPreview) {
+      // Convert the dashboard variables into objects of interface type SqlExpression using the default value, default operator and the variable name
+      const expr: SqlExpression[] = dashboardVariables.map(variable => {
+        return {
+          variableName: variable.variableName,
+          operator: variable.defaultOperator as SqlExpressionOperator, // Assuming defaultOperator is a valid SqlExpressionOperator
+          value: JSON.parse(variable.defaultValue || '[]'), // Assuming defaultValue is a string or can be converted to a string array
+        };
+      });
+      expressions.push(...expr);
+    }
+    else {
+      expressions.push(...inputExpressions);
+    }
+    return expressions;
+  }
+
+  private async loadQuestion(id: number) {
+    const repo = this.entityManager.getRepository(Question);
+
+    // Load the dashboard record using the field
+    const question = await repo.findOne({
+      where: {
+        id,
+      },
+      relations: ['questionSqlDatasetConfigs', 'dashboard', 'dashboard.dashboardVariables'],
+    });
+    return question;
+  }
+
+}

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

@@ -18,88 +18,54 @@ export class SchedulerServiceImpl implements ISchedulerService {
         private readonly solidRegistry: SolidRegistry,
     ) { }
 
-    // @Cron(CronExpression.EVERY_MINUTE)
-    // async runScheduledJobs(): Promise<void> {
-    //     const now = new Date();
-
-    //     const dueScheduledJobs = await this.scheduledJobRepo.find({
-    //         where: {
-    //             isActive: true,
-    //             nextRunAt: LessThanOrEqual(now),
-    //         },
-    //     });
-
-    //     for (const dueScheduledJob of dueScheduledJobs) {
-    //         try {
-    //             const jobName = dueScheduledJob.job;
-    //             // @ts-ignore                
-    //             // const jobHandler = this.jobMap[jobName];
-    //             // const jobHandler = ''; 
-    //             const jobHandler: IScheduledJob | undefined = this.solidRegistry.getScheduledJobProviderInstance(jobName)
-
-    //             if (!jobHandler) {
-    //                 this.logger.warn(`No job service found for: ${jobName}`);
-    //                 continue;
-    //             }
-
-    //             await jobHandler.executeReminder(dueScheduledJob);
-
-    //             // Update nextRunAt and lastRunAt based on frequency
-    //             dueScheduledJob.lastRunAt = now;
-    //             dueScheduledJob.nextRunAt = this.computeNextRunAt(dueScheduledJob);
-    //             await this.scheduledJobRepo.save(dueScheduledJob);
-
-    //             this.logger.log(`Successfully ran job: ${jobName}`);
-    //         } catch (err) {
-    //             this.logger.error(`Failed to run job for reminder ${dueScheduledJob.id}`, err.stack);
-    //         }
-    //     }
-    // }
-
-    // private computeNextRunAt(reminder: ScheduledJob): Date {
-    //     const now = new Date();
-    //     switch (reminder.frequency) {
-    //         case 'daily':
-    //             return new Date(now.getTime() + 24 * 60 * 60 * 1000);
-    //         case 'weekly':
-    //             return new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000);
-    //         case 'monthly':
-    //             return new Date(now.setMonth(now.getMonth() + 1));
-    //         default:
-    //             return new Date(now.getTime() + 24 * 60 * 60 * 1000); // default fallback
-    //     }
-    // }
-
     @Cron(CronExpression.EVERY_MINUTE)
     async runScheduledJobs(): Promise<void> {
         const now = new Date();
+
+        this.logger.log(`[${now.getTime()}]: scheduler service started run...`);
         const dueJobs = await this.scheduledJobRepo.find({
-            where: {
-                isActive: true,
-                nextRunAt: LessThanOrEqual(now),
-            },
+            where: [
+                {
+                    isActive: true,
+                    nextRunAt: LessThanOrEqual(now),
+                },
+                // Newly created jobs are also picked for examination 
+                {
+                    isActive: true,
+                    nextRunAt: null,
+                },
+            ],
         });
 
+        this.logger.log(`[${now.getTime()}]: scheduler service identified ${dueJobs.length} jobs to run...`);
+
         for (const job of dueJobs) {
+            this.logger.log(`[${now.getTime()}]: scheduler service attempting to run job ${job.job}`);
             try {
                 if (!this.shouldRunNow(job, now)) {
+                    this.logger.log(`[${now.getTime()}]: scheduler service skipping job ${job.job}`);
                     continue;
                 }
 
                 const handler = this.solidRegistry.getScheduledJobProviderInstance(job.job);
                 if (!handler) {
-                    this.logger.warn(`No job handler found for job: ${job.job}`);
+                    this.logger.warn(`[${now.getTime()}]: scheduler service skipping because job handler not found: ${job.job}`);
                     continue;
                 }
 
+                this.logger.log(`[${now.getTime()}]: scheduler service about to run job ${job.job}`);
                 await handler.executeReminder(job);
+                this.logger.log(`[${now.getTime()}]: scheduler service finished running job ${job.job}`);
+
                 job.isActive = true;
                 job.lastRunAt = now;
                 job.nextRunAt = this.computeNextRunAt(job, now);
+                this.logger.log(`[${now.getTime()}]: scheduler service coomputed next run for ${job.job} as ${job.nextRunAt}`);
+
                 await this.scheduledJobRepo.save(job);
-                this.logger.log(`Successfully ran job: ${job.job}`);
+                this.logger.log(`[${now.getTime()}]: scheduler service finished running job: ${job.job}`);
             } catch (err) {
-                this.logger.error(`Failed to run job ${job.job}`, err.stack);
+                this.logger.error(`[${now.getTime()}]: scheduler service failed to run job ${job.job}`, err.stack);
             }
         }
     }
@@ -143,8 +109,10 @@ export class SchedulerServiceImpl implements ISchedulerService {
         const base = new Date(from);
 
         switch (job.frequency.toLowerCase()) {
-            case 'once':
-                return null; // don't reschedule
+            // case 'once':
+            //     return null; // don't reschedule
+            case 'every minute':
+                return new Date(base.getTime() + 1 * 60 * 1000);
             case 'hourly':
                 return new Date(base.getTime() + 60 * 60 * 1000);
             case 'daily':
@@ -155,9 +123,9 @@ export class SchedulerServiceImpl implements ISchedulerService {
                 const next = new Date(base);
                 next.setMonth(base.getMonth() + 1);
                 return next;
-            case 'custom':
-                // Optional: let job handler decide via metadata or registry
-                return new Date(base.getTime() + 24 * 60 * 60 * 1000);
+            // case 'custom':
+            //     // Optional: let job handler decide via metadata or registry
+            //     return new Date(base.getTime() + 24 * 60 * 60 * 1000);
             default:
                 return new Date(base.getTime() + 24 * 60 * 60 * 1000);
         }

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

@@ -0,0 +1,41 @@
+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";
+
+
+@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.map(i => {
+            return { label: i.name, value: i.name };
+        });
+    }
+}

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

@@ -0,0 +1,41 @@
+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/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
+    };
+  }
+}