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

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

package/src/services/genai/mcp-handlers/solid-create-dashboard-mcp-handler.service.ts

@@ -1,114 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import { plainToInstance } from "class-transformer";
-import { CreateDashboardDto } from "src/dtos/create-dashboard.dto";
-import { UpdateMenuItemMetadataDto } from "src/dtos/update-menu-item-metadata.dto";
-import { AiInteraction } from "src/entities/ai-interaction.entity";
-import { Dashboard } from "src/entities/dashboard.entity";
-import { IMcpToolResponseHandler } from "../../../interfaces";
-import { ActionMetadataService } from "../../action-metadata.service";
-import { DashboardService } from "../../dashboard.service";
-import { MenuItemMetadataService } from "../../menu-item-metadata.service";
-import { ModelMetadataService } from "../../model-metadata.service";
-import { ModuleMetadataService } from "../../module-metadata.service";
-import { RoleMetadataService } from "../../role-metadata.service";
-
-@Injectable()
-export class SolidCreateDashboardWithWidgetsMcpHandler implements IMcpToolResponseHandler {
-
-    constructor(
-        private readonly dashboardService: DashboardService,
-        private readonly actionMetadataService: ActionMetadataService,
-        private readonly menuItemMetadataService: MenuItemMetadataService,
-        private readonly moduleMetadataService: ModuleMetadataService,
-        private readonly modelMetadataService: ModelMetadataService,
-        private readonly roleService: RoleMetadataService, // Assuming roleService is a Mongoose model, adjust as necessary
-    ) {
-    }
-
-    async apply(aiInteraction: AiInteraction) {
-        const escapedMessage = aiInteraction.message.replace(/\\'/g, "'");
-        const aiResponseMessage = JSON.parse(escapedMessage);
-        const { data } = aiResponseMessage;
-        const { schema } = data;
-        const { dashboardDto, dashboard } = await this.createDashboard(schema);
-
-        const { moduleUserKey, actionMetadataEntity } = await this.createActionMetadataEntry(dashboardDto, dashboard);
-
-        await this.createMenuItemEntry(dashboard, moduleUserKey, actionMetadataEntity);
-
-        // TODO: decide on some shape to return hre...
-        return {
-            seedingRequired: false,
-            serverRebooting: false,
-        }
-    }
-
-
-    private async createMenuItemEntry(dashboard: Dashboard, moduleUserKey: string, actionMetadataEntity: any) {
-        const menuData = {
-            displayName: dashboard.displayName || dashboard.name,
-            name: `${moduleUserKey}-${dashboard.name}-dashboard-menu-item`,
-            sequenceNumber: 1,
-            actionUserKey: actionMetadataEntity.name,
-            moduleUserKey: moduleUserKey,
-            parentMenuItemUserKey: '',
-        };
-
-        const adminRole = await this.roleService.findRoleByName('Admin');
-        const specifiedRoles = menuData['roles'];
-
-        // If the developer has specified roles, then resolve them, making sure that admin role is also given.
-        const specifiedRoleObjects = [adminRole];
-        if (specifiedRoles) {
-            for (let i = 0; i < specifiedRoles.length; i++) {
-                const specifiedRole = specifiedRoles[i];
-                const specifiedRoleObject = await this.roleService.findRoleByName(specifiedRole);
-                if (!specifiedRoleObject) {
-                    throw new Error(`Invalid role: (${specifiedRole}) specified against menu with display name ${menuData.displayName}.`);
-                }
-                specifiedRoleObjects.push(specifiedRoleObject);
-            }
-        }
-
-        menuData['roles'] = specifiedRoleObjects;
-        menuData['action'] = await this.actionMetadataService.findOneByUserKey(menuData.actionUserKey);
-        menuData['module'] = await this.moduleMetadataService.findOneByUserKey(menuData.moduleUserKey);
-
-        if (menuData.parentMenuItemUserKey) {
-            menuData['parentMenuItem'] = await this.menuItemMetadataService.findOneByUserKey(menuData.parentMenuItemUserKey);
-        } else {
-            menuData['parentMenuItem'] = null;
-        }
-        await this.menuItemMetadataService.upsert(menuData as unknown as UpdateMenuItemMetadataDto);
-    }
-
-    private async createActionMetadataEntry(dashboardDto: CreateDashboardDto, dashboard: Dashboard) {
-        const moduleUserKey = dashboardDto.moduleUserKey;
-        const actionMetadata = {
-            name: `${dashboard.name}-view`,
-            displayName: dashboard.displayName || dashboard.name,
-            type: 'custom',
-            domain: "{}",
-            context: "{}",
-            customComponent: `/admin/core/${moduleUserKey}/dashboards?dashboardName=${dashboard.name}`,
-            customIsModal: true,
-            serverEndpoint: '',
-            moduleUserKey: moduleUserKey,
-            modelUserKey: '',
-            viewUserKey: `${dashboard.name}-view`,
-        };
-        actionMetadata['module'] = await this.moduleMetadataService.findOneByUserKey(actionMetadata.moduleUserKey);
-        if (actionMetadata.modelUserKey) {
-            actionMetadata['model'] = await this.modelMetadataService.findOneByUserKey(actionMetadata.modelUserKey);
-        }
-        const actionMetadataEntity = await this.actionMetadataService.upsert(actionMetadata);
-        return { moduleUserKey, actionMetadataEntity };
-    }
-
-    private async createDashboard(aiResponseMessage: any) {
-        const dashboardDto = plainToInstance(CreateDashboardDto, aiResponseMessage);
-        dashboardDto['layoutJson'] = JSON.stringify(dashboardDto['layoutJson']);
-        const dashboard = await this.dashboardService.create(dashboardDto, []);
-        return { dashboardDto, dashboard };
-    }
-}

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

@@ -1,38 +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 SolidCreateDashboardQuestionMcpHandler implements IMcpToolResponseHandler {
-
-    constructor(
-        private readonly dashboardQuestionService: DashboardQuestionService,
-    ) {
-    }
-
-    async apply(aiInteraction: AiInteraction) {
-        const escapedMessage = aiInteraction.message.replace(/\\'/g, "'");
-        const aiResponseMessage = JSON.parse(escapedMessage);
-
-        //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, aiResponseMessage);
-
-        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-create-dashboard-question-sql-dataset-config-mcp-handler.service.ts

@@ -1,40 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import { plainToInstance } from "class-transformer";
-import { AiInteraction } from "src/entities/ai-interaction.entity";
-import { IMcpToolResponseHandler } from "../../../interfaces";
-import { DashboardQuestionSqlDatasetConfigService } from "../../dashboard-question-sql-dataset-config.service";
-import { CreateDashboardQuestionSqlDatasetConfigDto } from "src/dtos/create-dashboard-question-sql-dataset-config.dto";
-
-@Injectable()
-export class SolidCreateDashboardQuestionSqlDatasetConfigMcpHandler implements IMcpToolResponseHandler {
-
-    constructor(
-        private readonly dashboardQuestionSqlDatasetConfigService: DashboardQuestionSqlDatasetConfigService,
-    ) {
-    }
-
-    async apply(aiInteraction: AiInteraction) {
-        // const aiResponse = JSON.parse(aiInteraction.message);
-        const escapedMessage = aiInteraction.message.replace(/\\'/g, "'");
-        const aiResponseMessage = JSON.parse(escapedMessage);
-
-        // 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 = aiResponse['message'].replace(/\\'/g, "'");
-        // const dashboardUserKey = aiResponseMessageReplaced['dashboardUserKey'];
-        // if (!dashboardUserKey) {
-        //     throw new Error("Dashboard User Key is required to create a Dashboard Question.");
-        // }
-        const dto = plainToInstance(CreateDashboardQuestionSqlDatasetConfigDto, aiResponseMessage);
-        dto['options'] = JSON.stringify(dto['options']);
-
-        const dashboardQuestion = await this.dashboardQuestionSqlDatasetConfigService.create(dto, []);
-
-        // TODO: decide on some shape to return hre...
-        return {
-            seedingRequired: false,
-            serverRebooting: false,
-        }
-    }
-
-}

package/src/services/genai/mcp-handlers/solid-create-dashboard-widget-mcp-handler.service.ts

@@ -1,39 +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 SolidCreateDashboardWidgetMcpHandler implements IMcpToolResponseHandler {
-
-    constructor(
-        private readonly dashboardQuestionService: DashboardQuestionService,
-    ) {
-    }
-
-    async apply(aiInteraction: AiInteraction) {
-        const escapedMessage = aiInteraction.message.replace(/\\'/g, "'");
-        const aiResponseMessage = JSON.parse(escapedMessage);
-
-        //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, aiResponseMessage);
-        dashboardQuestionDto['questionSqlDatasetConfigsCommand'] = "update";
-
-        const dashboardQuestion = await this.dashboardQuestionService.create(dashboardQuestionDto, []);
-
-        // TODO: decide on some shape to return hre...
-        return {
-            seedingRequired: false,
-            serverRebooting: false,
-        }
-    }
-
-}

package/src/services/question-data-providers/chartjs-sql-data-provider.service.ts

@@ -1,121 +0,0 @@
-import { Injectable, Logger } 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 { getKpi, getLabels } from "./helpers";
-
-
-export enum SqlExpressionOperator {
-    EQUALS = '$equals',
-    NOT_EQUALS = '$notEquals',
-    CONTAINS = '$contains',
-    NOT_CONTAINS = '$notContains',
-    STARTS_WITH = '$startsWith',
-    ENDS_WITH = '$endsWith',
-    IN = '$in',
-    NOT_IN = '$notIn',
-    BETWEEN = '$between',
-    LT = '$lt',
-    LTE = '$lte',
-    GT = '$gt',
-    GTE = '$gte'
-}
-
-export interface SqlExpression {
-    variableName: string; // The name of the variable in the SQL query
-    operator: SqlExpressionOperator; // The operator to use for the replacement (e.g., '=', '>', '<', etc.)
-    value: string[]; // The value to replace the variable with
-}
-
-@DashboardQuestionDataProvider()
-@Injectable()
-export class ChartJsSqlDataProvider implements IDashboardQuestionDataProvider<QuestionSqlDataProviderContext, any> {
-    private readonly logger = new Logger(ChartJsSqlDataProvider.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 "ChartJsSqlDataProvider";
-    }
-
-    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 data = {
-        //     labels: ['January', 'February', 'March', 'April', 'May', 'June', 'July'],
-        //     datasets: [
-        //         {
-        //             label: 'Dataset 1',
-        //             data: labels.map(() => faker.number.int({ min: 0, max: 1000 })),
-        //             backgroundColor: 'rgba(255, 99, 132, 0.5)',
-        //         },
-        //         {
-        //             label: 'Dataset 2',
-        //             data: labels.map(() => faker.number.int({ min: 0, max: 1000 })),
-        //             backgroundColor: 'rgba(53, 162, 235, 0.5)',
-        //         },
-        //         {
-        //             label: 'Dataset 3',
-        //             data: labels.map(() => faker.number.int({ min: 0, max: 1000 })),
-        //             backgroundColor: 'rgba(53, 235, 162, 0.5)',
-        //         },
-        //     ],
-        // };
-
-        // TODO: Load the set of labels by using a separate field on the question entity.
-
-        let datasetIdx = 0;
-        const datasets = [];
-
-        const labels: string[] = await getLabels(question, expressions, this.entityManager, this.sqlExpressionResolver);
-        const kpi: string = await getKpi(question, expressions, this.entityManager, this.sqlExpressionResolver);
-
-        // const question = context.question;
-        for (const questionSqlDatasetConfig of question.questionSqlDatasetConfigs) {
-
-            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);
-
-            // Also for each data set we create the dataset object as is expected by ChartJs.
-            const data = [];
-            for (let i = 0; i < results.length; i++) {
-                const result = results[i];
-                data.push(result[questionSqlDatasetConfig.valueColumnName]);
-            }
-            datasets.push({
-                label: questionSqlDatasetConfig.datasetDisplayName,
-                data: data,
-                ...JSON.parse(questionSqlDatasetConfig.options || '{}'),
-            });
-
-            datasetIdx++;
-        }
-
-        return {
-            kpi,
-            visualizedAs: question.visualisedAs,
-            visualizationData: {
-                labels,
-                datasets
-            }
-        };
-
-    }
-
-
-}

package/src/services/question-data-providers/helpers.ts

@@ -1,30 +0,0 @@
-import { DashboardQuestion } from "src/entities/dashboard-question.entity";
-import { EntityManager } from "typeorm";
-import { SqlExpression } from "./chartjs-sql-data-provider.service";
-import { SqlExpressionResolverService } from "../sql-expression-resolver.service";
-
-export async function getLabels(question: DashboardQuestion, expressions: SqlExpression[], entityManager: EntityManager, sqlExpressionResolver: SqlExpressionResolverService): Promise<string[]> {
-    const sql = question.labelSql;
-    if (!sql) {
-        return [];
-    } 
-    const sqlReplacementResult = sqlExpressionResolver.resolveSqlWithExpressions(sql, expressions || []);
-   
-    const labelResults = await entityManager.query(sqlReplacementResult.rawSql, sqlReplacementResult.parameters);
-    
-    // Assuming labelResults has a single row with a 'label' field
-    // Map the label results to the labels array
-    const labels: string[] = labelResults.map((result: { [x: string]: string; }) => result['label']);
-    return labels;
-}
-
-export async function getKpi(question: DashboardQuestion, expressions: SqlExpression[], entityManager: EntityManager, sqlExpressionResolver: SqlExpressionResolverService): Promise<string> {
-    const sql = question.kpiSql;
-    if (!sql) {
-        return "";
-    }
-    const sqlReplacementResult = sqlExpressionResolver.resolveSqlWithExpressions(sql, expressions || []);
-    const result = await entityManager.query(sqlReplacementResult.rawSql, sqlReplacementResult.parameters);
-    const kpiResult = result.pop();
-    return kpiResult?.kpi || "";
-}