@solidxai/core 0.1.10-beta.22 → 0.1.10-beta.23

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;
-  }
-
-}

package/src/services/dashboard-selection-providers/dashboard-variable-sql-dynamic-provider.service.ts

@@ -1,56 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import { IDashboardVariableSelectionProvider, ISelectionProviderContext, ISelectionProviderValues } from "../../interfaces";
-// import localeCodes from 'locale-codes';
-import { EntityManager } from "typeorm";
-import { DashboardVariableSelectionProvider } from "src/decorators/dashboard-selection-provider.decorator";
-
-@DashboardVariableSelectionProvider()
-@Injectable()
-export class DashboardVariableSQLDynamicProvider implements IDashboardVariableSelectionProvider<ISelectionProviderContext> {
-
-    constructor(private readonly entityManager: EntityManager) {
-    }
-
-    help(): string {
-        return "# Get the dashboard variable after executing the SQL query configured for the dashboard variable.\n";
-    }
-
-    name(): string {
-        return 'DashboardVariableSQLDynamicProvider';
-    }
-
-    async value(optionValue: string, ctxt: ISelectionProviderContext): Promise<ISelectionProviderValues | any> {
-        throw new Error("DashboardVariableSQLDynamicProvider does not support value method. Use values method instead.");
-    }
-
-    async values(query: string, ctxt: ISelectionProviderContext): Promise<readonly ISelectionProviderValues[]> {
-        const { sql, limit, offset } = ctxt as unknown as { sql: string, limit?: number, offset?: number };
-        if (!sql) {
-            throw new Error("DashboardVariableSQLDynamicProvider requires a SQL query to be provided in the context.");
-        }
-
-        // Here you would execute the SQL query against your database
-        // For demonstration, let's assume we have a mock database function that executes the SQL query
-        const results = await this.entityManager.query(this.appendLimitOffset(sql), [limit, offset]);
-
-        // Transform the results into the expected format
-        return results.map((result: any) => {
-            const transformedResult: ISelectionProviderValues = {
-                value: result.value, // Assuming the result has a 'value' field
-                label: result.label, // Assuming the result has a 'label' field
-                // Add any other fields you need to transform here
-            };
-            return transformedResult;
-        });
-    }
-
-    appendLimitOffset(sql: string): string {
-        // Strip trailing semicolon if present
-        const trimmedSql = sql.trim().replace(/;$/, '');
-
-        // Append the LIMIT/OFFSET
-        const finalSql = `${trimmedSql} LIMIT $1 OFFSET $2`; // FIXME This works with PostgreSQL. for mysql use ?. For this we will need to identify the datasource using the model for the particular dashboard variable
-
-        return finalSql;
-    }
-}

package/src/services/dashboard-selection-providers/dashboard-variable-test-dynamic-provider.service.ts

@@ -1,37 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import { IDashboardVariableSelectionProvider, ISelectionProviderContext, ISelectionProviderValues } from "../../interfaces";
-// import localeCodes from 'locale-codes';
-import { EntityManager } from "typeorm";
-import { DashboardVariableSelectionProvider } from "src/decorators/dashboard-selection-provider.decorator";
-
-@DashboardVariableSelectionProvider()
-@Injectable()
-export class DasbhoardVariableTestDynamicProvider implements IDashboardVariableSelectionProvider<ISelectionProviderContext> {
-
-    constructor(private readonly entityManager: EntityManager) {
-    }
-
-    help(): string {
-        return "# Get the dashboard variable values.\n";
-    }
-
-    name(): string {
-        return 'DasbhoardVariableTestDynamicProvider';
-    }
-
-    async value(optionValue: string, ctxt: ISelectionProviderContext): Promise<ISelectionProviderValues | any> {
-        throw new Error("DasbhoardVariableTestDynamicProvider does not support value method. Use values method instead.");
-    }
-
-    async values(query: string, ctxt: ISelectionProviderContext): Promise<readonly ISelectionProviderValues[]> {
-        // Return some dummy data for testing
-        const { sql, limit, offset } = ctxt as unknown as { sql: string, limit?: number, offset?: number };
-        return [
-            { value: '1', label: 'Option 1' },
-            { value: '2', label: 'Option 2' },
-            { value: '3', label: 'Option 3' },
-            { value: '4', label: 'Option 4' },
-        ]; 
-    }
-
-}

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

@@ -1,27 +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 { DashboardVariable } from '../entities/dashboard-variable.entity';
-import { DashboardVariableRepository } from 'src/repository/dashboard-variable.repository';
-
-@Injectable()
-export class DashboardVariableService extends CRUDService<DashboardVariable> {
-  private readonly logger = new Logger(this.constructor.name);
-  constructor(
-    @InjectEntityManager()
-    readonly entityManager: EntityManager,
-    // @InjectRepository(DashboardVariable, 'default')
-    // readonly repo: Repository<DashboardVariable>,
-    readonly repo: DashboardVariableRepository,
-    readonly moduleRef: ModuleRef,
-  ) {
-    super(entityManager, repo, 'dashboardVariable', 'solid-core', moduleRef);
-  }
-
-
-}

package/src/services/dashboard.service.ts

@@ -1,148 +0,0 @@
-import { Injectable, Logger, NotFoundException } 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 * as fs from 'fs/promises'; // Use the Promise-based version of fs for async/await
-import { SelectionDynamicSourceType } from 'src/dtos/create-dashboard-variable.dto';
-import { DashboardVariableSelectionDynamicQueryDto } from 'src/dtos/dashboard-variable-selection-dynamic-query.dto';
-import { DashboardVariable } from 'src/entities/dashboard-variable.entity';
-import { ModuleMetadataHelperService } from 'src/helpers/module-metadata-helper.service';
-import { SolidRegistry } from 'src/helpers/solid-registry';
-import { DashboardMapper } from 'src/mappers/dashboard-mapper';
-import { DashboardRepository } from 'src/repository/dashboard.repository';
-import { Dashboard } from '../entities/dashboard.entity';
-import { CreateDashboardDto } from 'src/dtos/create-dashboard.dto';
-
-
-export const SQL_DYNAMIC_PROVIDER_NAME = 'DashboardVariableSQLDynamicProvider';
-@Injectable()
-export class DashboardService extends CRUDService<Dashboard> {
-  private readonly logger = new Logger(this.constructor.name);
-  constructor(
-    @InjectEntityManager()
-    readonly entityManager: EntityManager,
-    readonly repo: DashboardRepository, // Assuming you have a DashboardRepository for custom queries
-    readonly moduleRef: ModuleRef,
-    readonly solidRegistry: SolidRegistry, // Assuming solidRegistry is injected for selection providers
-    readonly moduleMetadataHelperService: ModuleMetadataHelperService,
-    readonly dashboardMapper: DashboardMapper,
-  ) {
-    super(entityManager, repo, 'dashboard', 'solid-core', moduleRef);
-  }
-
-
-  async create(createDto: CreateDashboardDto, files: Express.Multer.File[]) {
-    createDto.name = createDto.name.trim().replace(/\s+/g, '-').toLowerCase();
-    return super.create(createDto, files);
-  }
-
-  async getSelectionDynamicValues(query: DashboardVariableSelectionDynamicQueryDto) {
-    // Get the dashboard variable repo
-    const dashboardVariable = await this.loadDashboardVariable(query.variableId);
-
-    // Get the providerName and context for the dashboard variable
-    const [providerName, context] = this.getProviderNameAndContext(dashboardVariable, query);
-
-    // Get hold of the provider instance from the SolidRegistry
-    const selectionProviderInstance = this.solidRegistry.getDashboardVariableSelectionProviderInstance(providerName);
-    if (!selectionProviderInstance) {
-      throw new NotFoundException(`Field incorrectly configured. No provider with name ${providerName} registered in backend.`);
-    }
-
-    // 4. Call the provider's getSelectionDynamicValues method
-    return selectionProviderInstance.values(query.query, context);
-  }
-
-
-  private getProviderNameAndContext(dashboardVariable: DashboardVariable, query: DashboardVariableSelectionDynamicQueryDto): [string, any] {
-    const sourceType = dashboardVariable.selectionDynamicSourceType;
-
-    // Get the appropriate provide name based on the source type
-    let providerName: string;
-    const context = { limit: query.limit, offset: query.offset };
-    switch (sourceType) {
-      case SelectionDynamicSourceType.SQL:
-        providerName = SQL_DYNAMIC_PROVIDER_NAME;
-        context['sql'] = dashboardVariable.selectionDynamicSQL;
-        break;
-      case SelectionDynamicSourceType.PROVIDER:
-        providerName = dashboardVariable.selectionDynamicProviderName;
-        break;
-      default:
-        throw new Error(`Unsupported selection dynamic source type: ${sourceType}`);
-    }
-    return [providerName, context];
-  }
-
-  private async loadDashboardVariable(variableId: number) {
-    const dashboardVariableRepo = this.entityManager.getRepository(DashboardVariable);
-
-    // Load the dashboard record using the field
-    const dashboardVariable = await dashboardVariableRepo.findOne({
-      where: {
-        id: variableId,
-      },
-    });
-    return dashboardVariable;
-  }
-
-  async saveDashboardToConfig(entity: Dashboard) {
-    if (!entity) {
-      this.logger.debug('No entity found in the DashboardSubscriber saveDashboardToConfig method');
-      return;
-    }
-
-    // Validate dashboard details
-    const dashboard = entity as Dashboard;
-    const moduleMetadata = entity.module;
-    if (!moduleMetadata) {
-      throw new Error(`Module metadata not found for dashboard id ${entity.id}`);
-    }
-
-    // Get config file details
-    const { filePath, metaData } = await this.getConfigFileDetails(moduleMetadata.name);
-    if (!filePath || !metaData) {
-      throw new Error(`Configuration details not found for module: ${moduleMetadata.name}`);
-    }
-
-    // Write the dashboard to the config file
-    await this.writeToConfig(metaData, dashboard, filePath);
-  }
-
-  private async getConfigFileDetails(moduleName: string): Promise<{ filePath: string; metaData: any }> {
-    const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(moduleName);
-    try {
-      await fs.access(filePath);
-    } catch (error: any) {
-      throw new Error(`Configuration file not found for module: ${moduleName}`);
-    }
-    const metaData = await this.moduleMetadataHelperService.getModuleMetadataConfiguration(filePath);
-    return { filePath, metaData };
-  }
-
-  private async writeToConfig(metaData: any, dashboard: Dashboard, filePath: string) {
-    if (metaData.dashboards && Array.isArray(metaData.dashboards)) {
-      const dashboardIndex = metaData.dashboards?.findIndex((dashboardFromFile: { name: string; }) => dashboardFromFile.name === dashboard.name);
-      const dto = await this.dashboardMapper.toDto(dashboard);
-      if (dashboardIndex !== -1) {
-        metaData.dashboards[dashboardIndex] = dto;
-      }
-      else {
-        metaData.dashboards.push(dto);
-      }
-    }
-    else {
-      const dashboards = [];
-      const dto = await this.dashboardMapper.toDto(dashboard);
-      dashboards.push(dto);
-      metaData.dashboards = dashboards;
-    }
-    // Write the updated object back to the file
-    const updatedContent = JSON.stringify(metaData, null, 2);
-    await fs.writeFile(filePath, updatedContent);
-  }
-}

package/src/services/genai/mcp-handlers/solid-add-question-to-dashboard-mcp-handler.service.ts

@@ -1,43 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import { plainToInstance } from "class-transformer";
-import { CreateDashboardQuestionDto } from "src/dtos/create-dashboard-question.dto";
-import { AiInteraction } from "src/entities/ai-interaction.entity";
-import { IMcpToolResponseHandler } from "../../../interfaces";
-import { DashboardQuestionService } from "../../dashboard-question.service";
-
-@Injectable()
-export class SolidAddQuestionToDashboardMcpHandler implements IMcpToolResponseHandler {
-
-    constructor(
-        private readonly dashboardQuestionService: DashboardQuestionService,
-    ) {
-    }
-
-    async apply(aiInteraction: AiInteraction) {
-        const escapedMessage = aiInteraction.message.replace(/\\'/g, "'");
-        const aiResponseMessage = JSON.parse(escapedMessage);
-
-        const {data} = aiResponseMessage;
-        const { dashboardUserKey, schema} = data;
-
-        //FIXME: Replace \' with ' in the response, since the AI response seems to contain \' which is invalid JSON.
-        // This is a workaround for now, until we find a better solution.
-        // const aiResponseMessageReplaced = aiResponseMessage['message'].replace(/\\'/g, "'");
-        // const dashboardUserKey = aiResponseMessageReplaced['dashboardUserKey'];
-        // if (!dashboardUserKey) {
-        //     throw new Error("Dashboard User Key is required to create a Dashboard Question.");
-        // }
-        const dashboardQuestionDto = plainToInstance(CreateDashboardQuestionDto, schema);
-        dashboardQuestionDto['questionSqlDatasetConfigsCommand'] = "update";
-        dashboardQuestionDto['dashboardUserKey'] = dashboardUserKey;
-
-        const dashboardQuestion = await this.dashboardQuestionService.create(dashboardQuestionDto, []);
-
-        // TODO: decide on some shape to return hre...
-        return {
-            seedingRequired: false,
-            serverRebooting: false,
-        }
-    }
-
-}

package/src/services/genai/mcp-handlers/solid-add-variable-to-dashboard-mcp-handler.service.ts

@@ -1,44 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import { plainToInstance } from "class-transformer";
-import { CreateDashboardVariableDto } from "src/dtos/create-dashboard-variable.dto";
-import { AiInteraction } from "src/entities/ai-interaction.entity";
-import { DashboardVariableService } from "src/services/dashboard-variable.service";
-import { IMcpToolResponseHandler } from "../../../interfaces";
-
-@Injectable()
-export class SolidAddVariableToDashboardMcpHandler implements IMcpToolResponseHandler {
-
-    constructor(
-        private readonly dashboardVariableService: DashboardVariableService,
-    ) {
-    }
-
-    async apply(aiInteraction: AiInteraction) {
-        const escapedMessage = aiInteraction.message.replace(/\\'/g, "'");
-        const aiResponseMessage = JSON.parse(escapedMessage);
-
-        const {data} = aiResponseMessage;
-        const { dashboardUserKey, schema} = data;
-
-        //FIXME: Replace \' with ' in the response, since the AI response seems to contain \' which is invalid JSON.
-        // This is a workaround for now, until we find a better solution.
-        // const aiResponseMessageReplaced = aiResponseMessage['message'].replace(/\\'/g, "'");
-        // const dashboardUserKey = aiResponseMessageReplaced['dashboardUserKey'];
-        // if (!dashboardUserKey) {
-        //     throw new Error("Dashboard User Key is required to create a Dashboard Question.");
-        // }
-        const dashboardVariableDto = plainToInstance(CreateDashboardVariableDto, schema);
-        dashboardVariableDto['selectionStaticValues'] = JSON.stringify(dashboardVariableDto['selectionStaticValues'] || []);
-        dashboardVariableDto['defaultValue'] = JSON.stringify(dashboardVariableDto['defaultValue'] || []);
-        dashboardVariableDto['dashboardUserKey'] = dashboardUserKey;
-
-        const dashboardVariable = await this.dashboardVariableService.create(dashboardVariableDto, []);
-
-        // TODO: decide on some shape to return hre...
-        return {
-            seedingRequired: false,
-            serverRebooting: false,
-        }
-    }
-
-}