@solidxai/core 0.1.10-beta.9 → 0.1.10

package/src/repository/dashboard-question-sql-dataset-config.repository.ts

@@ -1,17 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { DashboardQuestionSqlDatasetConfig } from '../entities/dashboard-question-sql-dataset-config.entity';
-import { RequestContextService } from 'src/services/request-context.service';
-import { DataSource } from 'typeorm';
-import { SecurityRuleRepository } from './security-rule.repository';
-import { SolidBaseRepository } from './solid-base.repository';
-
-@Injectable()
-export class DashboardQuestionSqlDatasetConfigRepository extends SolidBaseRepository<DashboardQuestionSqlDatasetConfig> {
-    constructor(
-        readonly dataSource: DataSource,
-        readonly requestContextService: RequestContextService,
-        readonly securityRuleRepository: SecurityRuleRepository,
-    ) {
-        super(DashboardQuestionSqlDatasetConfig, dataSource, requestContextService, securityRuleRepository);
-    }
-}

package/src/repository/dashboard-question.repository.ts

@@ -1,17 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { DashboardQuestion } from '../entities/dashboard-question.entity';
-import { RequestContextService } from 'src/services/request-context.service';
-import { DataSource } from 'typeorm';
-import { SecurityRuleRepository } from './security-rule.repository';
-import { SolidBaseRepository } from './solid-base.repository';
-
-@Injectable()
-export class DashboardQuestionRepository extends SolidBaseRepository<DashboardQuestion> {
-    constructor(
-        readonly dataSource: DataSource,
-        readonly requestContextService: RequestContextService,
-        readonly securityRuleRepository: SecurityRuleRepository,
-    ) {
-        super(DashboardQuestion, dataSource, requestContextService, securityRuleRepository);
-    }
-}

package/src/repository/dashboard-variable.repository.ts

@@ -1,17 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { DashboardVariable } from '../entities/dashboard-variable.entity';
-import { RequestContextService } from 'src/services/request-context.service';
-import { DataSource } from 'typeorm';
-import { SecurityRuleRepository } from './security-rule.repository';
-import { SolidBaseRepository } from './solid-base.repository';
-
-@Injectable()
-export class DashboardVariableRepository extends SolidBaseRepository<DashboardVariable> {
-    constructor(
-        readonly dataSource: DataSource,
-        readonly requestContextService: RequestContextService,
-        readonly securityRuleRepository: SecurityRuleRepository,
-    ) {
-        super(DashboardVariable, dataSource, requestContextService, securityRuleRepository);
-    }
-}

package/src/repository/dashboard.repository.ts

@@ -1,101 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import { Dashboard } from "src/entities/dashboard.entity";
-import { ModuleMetadata } from "src/entities/module-metadata.entity";
-import { RequestContextService } from "src/services/request-context.service";
-import { DataSource } from "typeorm";
-import { SecurityRuleRepository } from "./security-rule.repository";
-import { SolidBaseRepository } from "./solid-base.repository";
-
-@Injectable()
-export class DashboardRepository extends SolidBaseRepository<Dashboard> {
-    constructor(
-        readonly dataSource: DataSource,
-        readonly requestContextService: RequestContextService,
-        readonly securityRuleRepository: SecurityRuleRepository,
-    ) {
-        super(Dashboard, dataSource, requestContextService, securityRuleRepository);
-    }
-
-
-    async upsertWithDto(createDto: any) {
-        const moduleMetadataRepository = this.dataSource.getRepository(ModuleMetadata);
-        const module = await moduleMetadataRepository.findOneBy({ name: createDto.moduleUserKey });
-
-        if (!module) throw new Error(`Module with key ${createDto.moduleUserKey} not found`);
-
-        const existingDashboard = await this.findOne({
-            where: { name: createDto.name },
-            relations: ['dashboardVariables', 'questions', 'questions.questionSqlDatasetConfigs'],
-        });
-
-        if (existingDashboard) {
-            // Update basic fields
-            existingDashboard.layoutJson = JSON.stringify(createDto.layoutJson ?? {});
-            existingDashboard.module = module;
-
-            // Upsert dashboard variables
-            existingDashboard.dashboardVariables = createDto.dashboardVariables?.map(variable => {
-                const existingVar = existingDashboard.dashboardVariables.find(v => v.variableName === variable.variableName);
-                if (existingVar) {
-                    return Object.assign(existingVar, {
-                        ...variable,
-                        selectionStaticValues: JSON.stringify(variable.selectionStaticValues ?? []),
-                        defaultValue: JSON.stringify(variable.defaultValue ?? []),
-                    });
-                }
-                return {
-                    ...variable,
-                    selectionStaticValues: JSON.stringify(variable.selectionStaticValues ?? []),
-                    defaultValue: JSON.stringify(variable.defaultValue ?? []),
-                };
-            }) ?? [];
-
-            // Upsert questions and their configs
-            existingDashboard.questions = createDto.questions?.map(question => {
-                const existingQuestion = existingDashboard.questions.find(q => q.name === question.name);
-                const questionData: any = {
-                    ...question,
-                    questionSqlDatasetConfigs: question.questionSqlDatasetConfigs?.map(cfg => {
-                        const existingCfg = existingQuestion?.questionSqlDatasetConfigs.find(c => c.datasetName === cfg.datasetName);
-                        if (existingCfg) {
-                            return Object.assign(existingCfg, {
-                                ...cfg,
-                                options: JSON.stringify(cfg.options ?? {}),
-                            });
-                        }
-                        return {
-                            ...cfg,
-                            options: JSON.stringify(cfg.options ?? {}),
-                        };
-                    }) ?? [],
-                };
-
-                return existingQuestion ? Object.assign(existingQuestion, questionData) : questionData;
-            }) ?? [];
-
-            return this.save(existingDashboard);
-        }
-
-        // Else: new dashboard
-        const dashboardData = {
-            ...createDto,
-            module,
-            layoutJson: JSON.stringify(createDto.layoutJson ?? {}),
-            dashboardVariables: createDto.dashboardVariables?.map(variable => ({
-                ...variable,
-                selectionStaticValues: JSON.stringify(variable.selectionStaticValues ?? []),
-                defaultValue: JSON.stringify(variable.defaultValue ?? []),
-            })),
-            questions: createDto.questions?.map(question => ({
-                ...question,
-                questionSqlDatasetConfigs: question.questionSqlDatasetConfigs?.map(cfg => ({
-                    ...cfg,
-                    options: JSON.stringify(cfg.options ?? {}),
-                })),
-            })),
-        };
-
-        const newDashboard = this.create(dashboardData);
-        return this.save(newDashboard);
-    }
-}

package/src/services/ai-interaction.service.ts

@@ -1,239 +0,0 @@
-import { BadRequestException, Injectable, Logger } from '@nestjs/common';
-import { ModuleRef } from "@nestjs/core";
-import { InjectEntityManager } from '@nestjs/typeorm';
-import { EntityManager } from 'typeorm';
-import type { SolidCoreSetting } from "src/services/settings/default-settings-provider.service";
-
-import { spawn } from 'child_process';
-import * as fs from 'fs/promises';
-import { ERROR_MESSAGES } from 'src/constants/error-messages';
-import { InvokeAiPromptDto } from 'src/dtos/invoke-ai-prompt.dto';
-import { McpResponse, TriggerMcpClientOptions } from 'src/interfaces';
-import { AiInteractionRepository } from 'src/repository/ai-interaction.repository';
-import { CRUDService } from 'src/services/crud.service';
-import { AiInteraction } from '../entities/ai-interaction.entity';
-import { McpHandlerFactory } from './genai/mcp-handlers/mcp-handler-factory.service';
-import { PublisherFactory } from './queues/publisher-factory.service';
-
-@Injectable()
-export class AiInteractionService extends CRUDService<AiInteraction> {
-  private readonly logger = new Logger(AiInteractionService.name);
-
-  constructor(
-    @InjectEntityManager()
-    readonly entityManager: EntityManager,
-    // @InjectRepository(AiInteraction, 'default')
-    // readonly repo: Repository<AiInteraction>,
-    readonly repo: AiInteractionRepository,
-    readonly moduleRef: ModuleRef,
-    readonly publisherFactory: PublisherFactory<TriggerMcpClientOptions>,
-    // readonly requestContextService: RequestContextService,
-    readonly mcpHandlerFactory: McpHandlerFactory,
-
-  ) {
-    super(entityManager, repo, 'aiInteraction', 'solid-core', moduleRef);
-  }
-
-  async triggerMcpClientJob(dto: InvokeAiPromptDto, userId: number, isAutoApply: boolean = false, threadId: string = null): Promise<any> {
-    // const activeUser: ActiveUserData = this.requestContextService.getActiveUser();
-
-    const aiInteraction = await this.create({
-      userId: userId,
-      threadId: threadId ? threadId : `thread-${userId}`,
-      role: 'human',
-      message: dto.prompt,
-      contentType: '',
-      errorMessage: '',
-      modelUsed: '',
-      responseTimeMs: 0,
-      metadata: '',
-      isAutoApply: isAutoApply
-    });
-    const m = {
-      payload: {
-        aiInteractionId: aiInteraction.id,
-        moduleName: dto.moduleName
-      },
-      parentEntity: 'aiInteraction',
-      parentEntityId: aiInteraction.id,
-    };
-
-    const queueMessageId = await this.publisherFactory.publish(m, 'TriggerMcpClientPublisher');
-
-    return {
-      queueMessageId: queueMessageId,
-      aiInteractionId: aiInteraction.id
-    }
-  }
-
-  /**
-   * Runs the Python MCP client with a prompt and returns the parsed JSON embedded in the 'response'.
-   * @param prompt - The question or instruction to send to the MCP client.
-   * @returns The parsed object inside the 'response' field of the JSON output.
-   */
-  async runMcpPrompt(prompt: string): Promise<McpResponse> {
-    const pythonExecutable = this.settingService.getConfigValue<SolidCoreSetting>('mcpPythonExecutable');
-    const mcpClient = this.settingService.getConfigValue<SolidCoreSetting>('mcpClient');
-
-    // TODO: We can return an error if the above env variables are not properly setup...
-    if (!pythonExecutable || !mcpClient) {
-      throw new BadRequestException(ERROR_MESSAGES.PYTHON_EXECUTABLE_NOT_CONFIGURED);
-    }
-
-    // Check if both paths are valid and accessible
-    try {
-      const [pyStat, clientStat] = await Promise.all([
-        fs.stat(pythonExecutable),
-        fs.stat(mcpClient),
-      ]);
-
-      if (!pyStat.isFile()) {
-        throw new BadRequestException(`MCP_PYTHON_EXECUTABLE path is not a file: ${pythonExecutable}`);
-      }
-
-      if (!clientStat.isFile()) {
-        throw new BadRequestException(`MCP_CLIENT path is not a file: ${mcpClient}`);
-      }
-
-    } catch (err: any) {
-      throw new BadRequestException(`Invalid MCP executable or client path: ${err.message}`);
-    }
-
-    // TODO: Refactor to use the command.service.ts instead...
-    return new Promise((resolve, reject) => {
-      this.logger.log(`Attempting to run command:`)
-      this.logger.log(`${pythonExecutable} ${mcpClient} "${prompt}"`);
-
-      const python = spawn(pythonExecutable, [mcpClient, `"${prompt}"`]);
-
-      let stdout = '';
-      let stderr = '';
-
-      python.stdout.on('data', (data) => {
-        stdout += data.toString();
-      });
-
-      python.stderr.on('data', (data) => {
-        stderr += data.toString();
-      });
-
-      python.on('close', (code) => {
-        this.logger.log(`Python script exited with code ${code}`);
-
-        if (code !== 0) {
-          this.logger.error(`Python script exited with a non-zero exit code: ${stderr}`);
-          return reject(new Error(`Python script exited with a non-zero exit code: ${stderr}`));
-        }
-
-        try {
-          this.logger.log(`Python script exited with zero exit code: ${stdout}`);
-          const raw: McpResponse = JSON.parse(stdout);
-
-          // Sometimes the raw.response might not be a valid json
-          // TODO: examine the content type of the raw response..
-          // if (raw.content_type==='json') {
-          // }
-          let parsedResponse = raw.response;
-          try {
-            parsedResponse = JSON.parse(raw.response);
-          }
-          catch (ex) {
-            this.logger.warn(`Attempting to parse mcp client response assuming it is JSON, however it is not: ${parsedResponse}`);
-            // raw.success = false
-          }
-          // Parse the response string into an object
-          // const parsedResponse = JSON.parse(raw.response);
-
-          // Replace the string with the parsed object
-          const enrichedRaw = {
-            ...raw,
-            response: parsedResponse,
-          };
-          // if (!raw.success) {
-          //   return reject(new Error(`MCP error: ${raw.errors?.join(', ')}`));
-          // }
-          // let cleaned = raw.response.trim();
-
-          // Don't need to re-parse this...
-          // const parsed = JSON.parse(cleaned);
-          // resolve(cleaned);
-
-          resolve(enrichedRaw);
-        } catch (err: any) {
-          reject(new Error(`Mcp Invocation Failed: ${err.message}`));
-        }
-      });
-    });
-  }
-
-  cleanResponse(response: string) {
-    this.logger.log(`mcp server response is: ${response}`);
-
-    // Remove markdown-style code block wrapper
-    if (response.startsWith('```json')) {
-      response = response.replace(/^```json/, '').trim();
-    }
-    if (response.endsWith('```')) {
-      response = response.replace(/```$/, '').trim();
-    }
-    this.logger.log(`mcp server response after removing doc tags is: ${response}`);
-
-    return response;
-  }
-
-  async applySolidAiInteraction(id: number) {
-    // Fetch the aiInteraction
-    const aiInteraction = await this.findOne(id, {
-      populate: ['user']
-    });
-    if (!aiInteraction) {
-      const m = `Unable to identified the aiInteraction entry that triggered this job... using id: ${id}`
-
-      // TODO: RESPONSE SHAPE ALERT Check if we want to control the shape of the response....
-      throw new Error(m);
-    }
-
-    // TODO: Validation: Check if JSON.parse(metadata).tools_invoked starts with solid_
-    let metadata: any = {};
-    try {
-      if (typeof aiInteraction.metadata === "string") {
-        metadata = JSON.parse(aiInteraction.metadata);
-      } else if (typeof aiInteraction.metadata === "object" && aiInteraction.metadata !== null) {
-        metadata = aiInteraction.metadata;
-      } else {
-        // optional fallback
-        metadata = {};
-      }
-    } catch (e) {
-      // TODO: RESPONSE SHAPE ALERT Check if we want to control the shape of the response....
-      throw new Error(`Invalid metadata JSON: ${e}`);
-    }
-
-    const toolsInvoked = metadata['tools_invoked'];
-    if (!toolsInvoked) {
-      // TODO: RESPONSE SHAPE ALERT Check if we want to control the shape of the response....
-      throw new Error(ERROR_MESSAGES.UNABLE_TO_RESOLVE_SOLID_COMMAND);
-    }
-
-    // TODO: OPTIMISATION for chained tool invocation, for now we are assuming only 1 tool was used.
-    const toolInvoked = toolsInvoked[0];
-
-    // TODO: use the toolInvoked to identify a service using some convention.
-    // TODO: Eg. if toolInvoked is solid_create_module <> SolidCreateModuleMcpToolHandler ... create a factory class to do this mapping and identify the relevant provider. 
-    const mcpToolHandler = this.mcpHandlerFactory.getInstance(toolInvoked);
-    if (!mcpToolHandler) {
-      // TODO: RESPONSE SHAPE ALERT Check if we want to control the shape of the response....
-      throw new Error(ERROR_MESSAGES.UNABLE_TO_RESOLVE_MCP_HANDLER);
-    }
-
-    const handlerApplicationResponse = await mcpToolHandler.apply(aiInteraction);
-
-    // TODO: This provider to implement an interface - IMcpToolResponseHandler ... apply(aiInteraction: AiInteraction)
-    // throw new Error('Method not implemented.');
-
-    // Mark the interaction as applied
-    await this.update(aiInteraction.id, { isApplied: true }, [], true);
-
-    return handlerApplicationResponse;
-  }
-}

package/src/services/dashboard-layout.service.ts

@@ -1,111 +0,0 @@
-import { Injectable, Logger } from '@nestjs/common';
-import { ModuleRef } from "@nestjs/core";
-import { InjectEntityManager } from '@nestjs/typeorm';
-import { EntityManager } from 'typeorm';
-
-import { CRUDService } from 'src/services/crud.service';
-import { DashboardLayout } from 'src/entities/dashboard-layout.entity';
-import { DashboardLayoutRepository } from 'src/repository/dashboard-layout.repository';
-import { CreateDashboardLayoutDto } from 'src/dtos/create-dashboard-layout.dto';
-import { RequestContextService } from './request-context.service';
-
-
-@Injectable()
-export class DashboardLayoutService extends CRUDService<DashboardLayout> {
-  private readonly logger = new Logger(this.constructor.name);
-  constructor(
-    @InjectEntityManager()
-    readonly entityManager: EntityManager,
-    readonly repo: DashboardLayoutRepository,
-    readonly requestContextService: RequestContextService,
-    readonly moduleRef: ModuleRef,
-  ) {
-    super(entityManager, repo, 'dashboardLayout', 'solid-core', moduleRef);
-  }
-
-  async upsertUserDashboardLayout(createDtos: CreateDashboardLayoutDto) {
-    const activeUser = this.requestContextService.getActiveUser();
-
-    if (!activeUser) {
-      throw new Error('User not found');
-    }
-
-    let userId = null;
-    if (activeUser.roles.includes('Admin')) {
-      userId = null;
-    } else {
-      userId = activeUser?.sub;
-    }
-    const existingLayout = await this.repo.findOne({
-      where: {
-        user: { id: userId },
-        dashboard: {
-          id: createDtos.dashboardId
-        }
-      },
-      relations: {
-        user: true,
-        dashboard: true,
-      }
-    });
-
-    if (existingLayout) {
-      return super.update(existingLayout.id, { layout: createDtos.layout }, [], true);
-    } else {
-      const createDto = {
-        layout: createDtos.layout,
-        dashboardId: createDtos.dashboardId,
-        uesrId: userId
-      }
-      return super.create(createDto, []);
-    }
-  }
-
-  async getUserDashboardLayoutByDashboardId(dashboardId: any) {
-    const activeUser = this.requestContextService.getActiveUser();
-
-    if (!activeUser) {
-      throw new Error('User not found');
-    }
-    const userId = activeUser?.sub;
-    const existingUserLayout = await this.repo.findOne({
-      where: {
-        user: { id: userId },
-        dashboard: {
-          id: dashboardId
-        }
-      },
-      relations: {
-        user: true,
-        dashboard: true,
-      }
-    });
-    if (existingUserLayout) {
-      // if dahsboard for userid exists 
-      return existingUserLayout;
-    }
-
-    // if not then check for default dashboard
-    const defaultLayout = await this.repo.findOne({
-      where: {
-        user: { id: null },
-        dashboard: {
-          id: dashboardId
-        }
-      },
-      relations: {
-        user: true,
-        dashboard: true,
-      }
-    });
-    if (defaultLayout) {
-      // if default layout exists return it
-      return defaultLayout;
-    } else {
-      // if default layout does not exist return empty layout 
-      return {
-        layout: null
-      }
-    }
-  }
-}

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

@@ -1,25 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { InjectEntityManager } from '@nestjs/typeorm';
-import { ModuleRef } from "@nestjs/core";
-import { EntityManager } from 'typeorm';
-
-import { CRUDService } from 'src/services/crud.service';
-
-
-import { DashboardQuestionSqlDatasetConfig } from '../entities/dashboard-question-sql-dataset-config.entity';
-import { DashboardQuestionSqlDatasetConfigRepository } from 'src/repository/dashboard-question-sql-dataset-config.repository';
-
-@Injectable()
-export class DashboardQuestionSqlDatasetConfigService extends CRUDService<DashboardQuestionSqlDatasetConfig>{
-  constructor(
-    @InjectEntityManager()
-    readonly entityManager: EntityManager,
-    // @InjectRepository(DashboardQuestionSqlDatasetConfig, 'default')
-    // readonly repo: Repository<DashboardQuestionSqlDatasetConfig>,
-    readonly repo: DashboardQuestionSqlDatasetConfigRepository,
-    readonly moduleRef: ModuleRef
-
- ) {
-   super(entityManager, repo, 'dashboardQuestionSqlDatasetConfig', 'solid-core', moduleRef);
- }
-}

package/src/services/dashboard-question.service.ts

@@ -1,150 +0,0 @@
-import { BadRequestException, Injectable, Logger, NotImplementedException } from '@nestjs/common';
-import { ModuleRef } from "@nestjs/core";
-import { InjectEntityManager } from '@nestjs/typeorm';
-import { EntityManager } from 'typeorm';
-
-import { CRUDService } from 'src/services/crud.service';
-
-
-import { DashboardVariable } from 'src/entities/dashboard-variable.entity';
-import { SolidRegistry } from 'src/helpers/solid-registry';
-import { DashboardQuestion } from '../entities/dashboard-question.entity';
-import { SqlExpression, SqlExpressionOperator } from './question-data-providers/chartjs-sql-data-provider.service';
-import { DashboardQuestionRepository } from 'src/repository/dashboard-question.repository';
-import { QuestionSqlDataProviderContext } from '../interfaces';
-
-enum SOURCE_TYPE {
-  SQL = 'sql',
-  PROVIDER = 'provider',
-}
-
-export const CHARTJS_SQL_DATA_PROVIDER_NAME = 'ChartJsSqlDataProvider';
-export const PRIME_REACT_METER_GROUP_SQL_DATA_PROVIDER_NAME = 'PrimeReactMeterGroupSqlDataProvider';
-export const PRIME_REACT_DATATABLE_SQL_DATA_PROVIDER_NAME = 'PrimeReactDatatableSqlDataProvider';
-
-export const INBUILT_SQL_DATA_PROVIDERS = [CHARTJS_SQL_DATA_PROVIDER_NAME, PRIME_REACT_METER_GROUP_SQL_DATA_PROVIDER_NAME, PRIME_REACT_DATATABLE_SQL_DATA_PROVIDER_NAME];
-
-@Injectable()
-export class DashboardQuestionService extends CRUDService<DashboardQuestion> {
-  private readonly logger = new Logger(this.constructor.name);
-  constructor(
-    @InjectEntityManager()
-    readonly entityManager: EntityManager,
-    // @InjectRepository(DashboardQuestion, 'default')
-    // readonly repo: Repository<DashboardQuestion>,
-    readonly repo: DashboardQuestionRepository,
-    readonly moduleRef: ModuleRef,
-    readonly solidRegistry: SolidRegistry, // Assuming solidRegistry is injected for data providers
-  ) {
-    super(entityManager, repo, 'dashboardQuestion', '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;
-    let context = {};
-
-    // Decide which data provider to use based on the question visualisation type if sourceType is SQL. 
-    if (question.sourceType === SOURCE_TYPE.SQL && ['bar', 'pie', 'line', 'donut'].includes(question.visualisedAs)) {
-      dataProvider = this.solidRegistry.getDashboardQuestionDataProviderInstance(CHARTJS_SQL_DATA_PROVIDER_NAME);
-      context = {
-        expressions,
-      } as QuestionSqlDataProviderContext;
-    }
-    if (question.sourceType === SOURCE_TYPE.SQL && ['prime-meter-group'].includes(question.visualisedAs)) {
-      dataProvider = this.solidRegistry.getDashboardQuestionDataProviderInstance(PRIME_REACT_METER_GROUP_SQL_DATA_PROVIDER_NAME);
-            context = {
-        expressions,
-      } as QuestionSqlDataProviderContext;
-    }
-    if (question.sourceType === SOURCE_TYPE.SQL && ['prime-datatable'].includes(question.visualisedAs)) {
-      dataProvider = this.solidRegistry.getDashboardQuestionDataProviderInstance(PRIME_REACT_DATATABLE_SQL_DATA_PROVIDER_NAME);
-      context = {
-        expressions,
-      } as QuestionSqlDataProviderContext;
-    }
-
-    // If a custom provider is specified, use that one instead
-    if (question.sourceType === SOURCE_TYPE.PROVIDER) {
-      dataProvider = this.solidRegistry.getDashboardQuestionDataProviderInstance(question.providerName);
-    }
-
-    if (!dataProvider) {
-      throw new NotImplementedException(`Invalid data source type ${question.sourceType}`);
-    }
-
-    return await dataProvider.getData(question, context);
-
-  }
-
-  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 {
-      // Loop through the dashboard variables and see if there is a matching input expression
-      // If there is, use that expression instead of the default value
-      for (const variable of dashboardVariables) {
-        const matchingInputExpression = inputExpressions.find(expr => expr.variableName === variable.variableName);
-        if (matchingInputExpression) {
-          expressions.push(matchingInputExpression);
-        }
-        else {
-          expressions.push({
-            variableName: variable.variableName,
-            operator: variable.defaultOperator as SqlExpressionOperator,
-            value: JSON.parse(variable.defaultValue || '[]'),
-          });
-        }
-      }
-      expressions.push(...expressions);
-    }
-
-    // Remove duplicate expressions based on variableName in the expressions array
-    const deduplicatedExpressions: SqlExpression[] = [];
-    const variableNames = new Set<string>();
-    for (const expr of expressions) {
-      if (!variableNames.has(expr.variableName)) {
-        deduplicatedExpressions.push(expr);
-        variableNames.add(expr.variableName);
-      }
-    }
-
-    return deduplicatedExpressions;
-  }
-
-  private async loadQuestion(id: number) {
-    const repo = this.entityManager.getRepository(DashboardQuestion);
-
-    // Load the dashboard record using the field
-    const question = await repo.findOne({
-      where: {
-        id,
-      },
-      relations: ['questionSqlDatasetConfigs', 'dashboard', 'dashboard.dashboardVariables'],
-    });
-    return question;
-  }
-
-}