@solidstarters/solid-core 1.2.135 → 1.2.137

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

@@ -1,4 +1,4 @@
-import { BadRequestException, Injectable } from '@nestjs/common';
+import { BadRequestException, Logger, Injectable } from '@nestjs/common';
 import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { EntityManager, Repository } from 'typeorm';
@@ -12,22 +12,16 @@ import { CrudHelperService } from 'src/services/crud-helper.service';
 import { spawn } from 'child_process';
 import { AiInteraction } from '../entities/ai-interaction.entity';
 import * as fs from 'fs/promises';
-import * as path from 'path';
-
-interface McpResponse {
-  success: boolean;
-  request: string;
-  response: string;
-  model?: string;
-  tools_invoked?: string[];
-  tool_calls?: any[];
-  duration_ms?: number;
-  errors?: string[];
-  trace?: string[];
-}
+import { McpResponse, TriggerMcpClientOptions } from 'src/interfaces';
+import { PublisherFactory } from './queues/publisher-factory.service';
+import { RequestContextService } from './request-context.service';
+import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
+import { McpToolResponseHandlerFactory } from './mcp-tool-response-handlers/mcp-tool-response-handler-factory.service';
 
 @Injectable()
 export class AiInteractionService extends CRUDService<AiInteraction> {
+  private readonly logger = new Logger(AiInteractionService.name);
+
   constructor(
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
@@ -39,18 +33,46 @@ export class AiInteractionService extends CRUDService<AiInteraction> {
     readonly entityManager: EntityManager,
     @InjectRepository(AiInteraction, 'default')
     readonly repo: Repository<AiInteraction>,
-    readonly moduleRef: ModuleRef
+    readonly moduleRef: ModuleRef,
+    readonly publisherFactory: PublisherFactory<TriggerMcpClientOptions>,
+    readonly requestContextService: RequestContextService,
+    readonly mcpToolResponseHandlerFactory: McpToolResponseHandlerFactory,
 
   ) {
     super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'aiInteraction', 'solid-core', moduleRef);
   }
 
+  async triggerMcpClientJob(prompt: string): Promise<string> {
+    const activeUser: ActiveUserData = this.requestContextService.getActiveUser();
+
+    const aiInteraction = await this.create({
+      userId: activeUser.sub,
+      threadId: `thread-${activeUser.sub}`,
+      role: 'human',
+      message: prompt,
+      contentType: '',
+      errorMessage: '',
+      modelUsed: '',
+      responseTimeMs: 0,
+      metadata: ''
+    });
+    const m = {
+      payload: {
+        aiInteractionId: aiInteraction.id,
+      },
+      parentEntity: 'aiInteraction',
+      parentEntityId: aiInteraction.id,
+    };
+
+    return await this.publisherFactory.publish(m, 'TriggerMcpClientPublisher');
+  }
+
   /**
    * 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<any> {
+  async runMcpPrompt(prompt: string): Promise<McpResponse> {
     const pythonExecutable = process.env.MCP_PYTHON_EXECUTABLE;
     const mcpClient = process.env.MCP_CLIENT;
 
@@ -78,9 +100,12 @@ export class AiInteractionService extends CRUDService<AiInteraction> {
       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]);
+      const python = spawn(pythonExecutable, [mcpClient, `"${prompt}"`]);
 
       let stdout = '';
       let stderr = '';
@@ -94,34 +119,93 @@ export class AiInteractionService extends CRUDService<AiInteraction> {
       });
 
       python.on('close', (code) => {
+        this.logger.log(`Python script exited with code ${code}`);
+
         if (code !== 0) {
-          return reject(new Error(`Python script exited with code ${code}: ${stderr}`));
+          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);
 
-          if (!raw.success) {
-            return reject(new Error(`MCP error: ${raw.errors?.join(', ')}`));
-          }
+          // if (!raw.success) {
+          //   return reject(new Error(`MCP error: ${raw.errors?.join(', ')}`));
+          // }
+          // let cleaned = raw.response.trim();
 
-          let cleaned = raw.response.trim();
+          // Don't need to re-parse this...
+          // const parsed = JSON.parse(cleaned);
+          // resolve(cleaned);
 
-          // Remove markdown-style code block wrapper
-          if (cleaned.startsWith('```json')) {
-            cleaned = cleaned.replace(/^```json/, '').trim();
-          }
-          if (cleaned.endsWith('```')) {
-            cleaned = cleaned.replace(/```$/, '').trim();
-          }
-
-          const parsed = JSON.parse(cleaned);
-          resolve(parsed);
+          resolve(raw);
         } catch (err: any) {
-          reject(new Error(`Failed to parse JSON: ${err.message}`));
+          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 = {};
+    try {
+      metadata = JSON.parse(aiInteraction.metadata);
+    }
+    catch (e) {
+      // TODO: RESPONSE SHAPE ALERT Check if we want to control the shape of the response....
+      throw new Error(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('Unable to resolve a solid_ command that was used to come up with this response.');
+    }
+
+    // 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.mcpToolResponseHandlerFactory.getInstance(toolInvoked);
+    if (!mcpToolHandler) {
+      // TODO: RESPONSE SHAPE ALERT Check if we want to control the shape of the response....
+      throw new Error('Unable to resolve a mcp tool handler.');
+    }
+
+    const handlerApplicationResponse = await mcpToolHandler.apply(aiInteraction);
+
+    // TODO: This provider to implement an interface - IMcpToolResponseHandler ... apply(aiInteraction: AiInteraction)
+    // throw new Error('Method not implemented.');
+
+    return handlerApplicationResponse;
+  }
 }

package/src/services/chatter-message.service.ts

@@ -125,7 +125,7 @@ export class ChatterMessageService extends CRUDService<ChatterMessage>{
 
     for (const field of auditFields) {
         const fieldValue = entity[field.name];
-        if (fieldValue !== undefined && fieldValue !== null) {
+        if (fieldValue !== undefined && fieldValue !== null && fieldValue !== '') {
             const messageDetail = new ChatterMessageDetails();
             messageDetail.chatterMessage = savedMessage;
             messageDetail.fieldName = field.name;
@@ -289,19 +289,25 @@ private formatFieldValueDisplay(field: any, value: any): string {
 }
 
 private hasValueChanged(newValue: any, oldValue: any): boolean {
-    if (newValue === oldValue) {
+    if (
+        (newValue === null || newValue === undefined) &&
+        (oldValue === null || oldValue === undefined)
+    ) {
         return false;
     }
 
-    if (newValue === null && oldValue === null) {
+    if (newValue === oldValue) {
         return false;
     }
 
-    if (newValue === undefined && oldValue === undefined) {
-        return false;
+    if (Array.isArray(newValue) && Array.isArray(oldValue)) {
+        return JSON.stringify(newValue) !== JSON.stringify(oldValue);
     }
 
-    if (Array.isArray(newValue) && Array.isArray(oldValue)) {
+    if (
+        typeof newValue === 'object' && newValue !== null &&
+        typeof oldValue === 'object' && oldValue !== null
+    ) {
         return JSON.stringify(newValue) !== JSON.stringify(oldValue);
     }
 

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

@@ -11,10 +11,10 @@ import { FileService } from 'src/services/file.service';
 import { CrudHelperService } from 'src/services/crud-helper.service';
 
 
-import { QuestionSqlDatasetConfig } from '../entities/question-sql-dataset-config.entity';
+import { DashboardQuestionSqlDatasetConfig } from '../entities/dashboard-question-sql-dataset-config.entity';
 
 @Injectable()
-export class QuestionSqlDatasetConfigService extends CRUDService<QuestionSqlDatasetConfig>{
+export class DashboardQuestionSqlDatasetConfigService extends CRUDService<DashboardQuestionSqlDatasetConfig>{
   constructor(
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
@@ -24,11 +24,11 @@ export class QuestionSqlDatasetConfigService extends CRUDService<QuestionSqlData
     readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
-    @InjectRepository(QuestionSqlDatasetConfig, 'default')
-    readonly repo: Repository<QuestionSqlDatasetConfig>,
+    @InjectRepository(DashboardQuestionSqlDatasetConfig, 'default')
+    readonly repo: Repository<DashboardQuestionSqlDatasetConfig>,
     readonly moduleRef: ModuleRef
 
  ) {
-   super(modelMetadataService, moduleMetadataService,  configService, fileService,  discoveryService, crudHelperService,entityManager, repo, 'questionSqlDatasetConfig', 'solid-core', moduleRef);
+   super(modelMetadataService, moduleMetadataService,  configService, fileService,  discoveryService, crudHelperService,entityManager, repo, 'dashboardQuestionSqlDatasetConfig', 'solid-core', moduleRef);
  }
 }

package/src/services/{question.service.ts → dashboard-question.service.ts}

@@ -13,7 +13,7 @@ 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 { DashboardQuestion } from '../entities/dashboard-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';
@@ -28,7 +28,7 @@ const PRIME_REACT_METER_GROUP_SQL_DATA_PROVIDER_NAME = 'PrimeReactMeterGroupSqlD
 const PRIME_REACT_DATATABLE_SQL_DATA_PROVIDER_NAME = 'PrimeReactDatatableSqlDataProvider';
 
 @Injectable()
-export class QuestionService extends CRUDService<Question> {
+export class DashboardQuestionService extends CRUDService<DashboardQuestion> {
   private readonly logger = new Logger(this.constructor.name);
   constructor(
     readonly modelMetadataService: ModelMetadataService,
@@ -39,12 +39,12 @@ export class QuestionService extends CRUDService<Question> {
     readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
-    @InjectRepository(Question, 'default')
-    readonly repo: Repository<Question>,
+    @InjectRepository(DashboardQuestion, 'default')
+    readonly repo: Repository<DashboardQuestion>,
     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);
+    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'dashboardQuestion', 'solid-core', moduleRef);
   }
 
   // Get the data for a specific question 
@@ -100,7 +100,7 @@ export class QuestionService extends CRUDService<Question> {
   }
 
   private async loadQuestion(id: number) {
-    const repo = this.entityManager.getRepository(Question);
+    const repo = this.entityManager.getRepository(DashboardQuestion);
 
     // Load the dashboard record using the field
     const question = await repo.findOne({

package/src/services/field-metadata.service.ts

@@ -929,6 +929,7 @@ export class FieldMetadataService implements OnApplicationBootstrap {
                     "type",
                     "ormType",
                     "isSystem",
+                    "computedFieldValueType",
                     "computedFieldTriggerConfig",
                     "computedFieldValueProvider",
                     "computedFieldValueProviderCtxt",

package/src/services/import-transaction.service.ts

@@ -496,7 +496,7 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
     };
   }
 
-  private async createErrorLogEntry(importTransaction: ImportTransaction, record: Record<string, any>, error: any) {
+  async createErrorLogEntry(importTransaction: ImportTransaction, record: Record<string, any>, error: any) {
     const importTransactionRepo = this.entityManager.getRepository(ImportTransactionErrorLog);
     // Create a new ImportTransactionErrorLog entry
     const rowNumber = uuidv4(); // Generate a unique row number or use page.rowNumber if available 
@@ -574,11 +574,39 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
         return this.populateDtoForNumber(dtoRecord, fieldMetadata, record, key);
       case SolidFieldType.boolean:
         return this.populateDtoForBoolean(dtoRecord, fieldMetadata, record, key);
+      case SolidFieldType.selectionStatic:
+      case SolidFieldType.selectionDynamic:
+        return this.populateDtoForSelectionValues(dtoRecord, fieldMetadata, record, key);
       default:
         dtoRecord[fieldMetadata.name] = record[key];
         return dtoRecord;
     }
   }
+  
+  private populateDtoForSelectionValues(dtoRecord: Record<string, any>, fieldMetadata: FieldMetadata, record: Record<string, any>, key: string) {
+    const rawValue = record[key];
+
+    if (rawValue == null) {
+      dtoRecord[fieldMetadata.name] = null;
+      return dtoRecord;
+    }
+
+    const isMultipleSelection = fieldMetadata.isMultiSelect;
+
+    if (isMultipleSelection) {
+      const selectionValues = String(rawValue)
+        .split(',')
+        .map(value => value.trim())
+        .filter(value => value !== '');
+
+      dtoRecord[fieldMetadata.name] = JSON.stringify(selectionValues);
+    } else {
+      dtoRecord[fieldMetadata.name] = rawValue; // Single select: assign directly
+    }
+
+    return dtoRecord;
+  }
+
 
   private populateDtoForBoolean(dtoRecord: Record<string, any>, fieldMetadata: FieldMetadata, record: Record<string, any>, key: string) {
     const booleanValue = Boolean(record[key]);

package/src/services/list-of-values.service.ts

@@ -39,6 +39,11 @@ export class ListOfValuesService extends CRUDService<ListOfValues> {
       },
     });
   }
+
+  async findAll(): Promise<ListOfValues[]> {
+    return await this.repo.find();
+  }
+  
   async upsert(updateListOfValuesDto: any) {
     // First check if module already exists using name
     const existingListOfValue = await this.repo.findOne({

package/src/services/mcp-tool-response-handlers/mcp-tool-response-handler-factory.service.ts

@@ -0,0 +1,36 @@
+import { Logger } from '@nestjs/common';
+import { Injectable } from '@nestjs/common';
+
+import { QueueMessage, QueuePublisher } from 'src/interfaces/mq';
+import { classify } from '@angular-devkit/core/src/utils/strings';
+import { SolidIntrospectService } from '../solid-introspect.service';
+import { IMcpToolResponseHandler } from 'src/interfaces';
+
+
+@Injectable()
+export class McpToolResponseHandlerFactory {
+    private readonly logger = new Logger(McpToolResponseHandlerFactory.name);
+
+    constructor(
+        private readonly solidIntrospectionService: SolidIntrospectService
+    ) {
+    }
+
+    getInstance(toolInvoked: string): IMcpToolResponseHandler {
+        toolInvoked = classify(toolInvoked);
+
+        let resolvedHandlerName = `${toolInvoked}McpToolResponseHandler`;
+
+        // Register all ISolidDatabaseModules implementations
+        let actualHandler = this.solidIntrospectionService.getProvider(resolvedHandlerName);
+        if (!actualHandler) {
+            throw new Error(`Unable to locate mcp tool handler with name ${resolvedHandlerName}`);
+        }
+
+        // type safe
+        const actualHandlerInstance: IMcpToolResponseHandler = actualHandler.instance;
+        this.logger.error(`Resolved mcp tool response handler with name ${actualHandler.name}`);
+
+        return actualHandlerInstance;
+    }
+}

package/src/services/mcp-tool-response-handlers/solid-create-module-mcp-tool-response-handler.service.ts

@@ -0,0 +1,52 @@
+import { Injectable } from "@nestjs/common";
+import { IMcpToolResponseHandler } from "../../interfaces";
+import { AiInteraction } from "src/entities/ai-interaction.entity";
+import { ModuleMetadataService } from "../module-metadata.service";
+import { CreateModuleMetadataDto } from "src/dtos/create-module-metadata.dto";
+import { SolidRegistry } from "src/helpers/solid-registry";
+
+@Injectable()
+export class SolidCreateModuleMcpToolResponseHandler implements IMcpToolResponseHandler {
+
+    constructor(
+        private readonly moduleMetadataService: ModuleMetadataService,
+        private readonly solidRegistry: SolidRegistry,
+
+    ) {
+    }
+
+    async apply(aiInteraction: AiInteraction) {
+        const aiResponse = JSON.parse(aiInteraction.message);
+
+        const moduleMetadata = aiResponse['moduleMetadata'];
+
+        // TODO: Validate if another module with same name exists, if it does then raise an error...
+
+        const createDto: CreateModuleMetadataDto = {
+            defaultDataSource: 'default',
+            description: moduleMetadata['description'],
+            displayName: moduleMetadata['displayName'],
+            isSystem: false,
+            menuIconUrl: '',
+            models: [],
+            name: moduleMetadata['name'],
+            menuSequenceNumber: 1
+        }
+
+        // This creates the module-metadata.json file....
+        const moduleObj = await this.moduleMetadataService.create(createDto);
+
+        const seeder = this.solidRegistry.getSeeders().filter((seeder) => seeder.name === 'ModuleMetadataSeederService').map((seeder) => seeder.instance).pop();
+
+        // Now we need to run solid seed & then solid refresh-model --name <module-name>
+        await this.moduleMetadataService.generateCode({ moduleId: moduleObj.id });
+
+        // solid seed ... this has to be run after reboot from the UI...
+        // await new Promise(resolve => setTimeout(resolve, 1000));
+        // await seeder.seed();
+
+        // TODO: decide on some shape to return hre...
+        return {}
+    }
+
+}

package/src/services/module-metadata.service.ts

@@ -213,7 +213,6 @@ export class ModuleMetadataService {
     }
   }
 
-
   async updateInDB(manager: EntityManager, id: number, updateModuleMetadataDto: UpdateModuleMetadataDto, files: Express.Multer.File[] = []) {
 
     const module = await this.moduleMetadataRepo.preload({
@@ -286,7 +285,6 @@ export class ModuleMetadataService {
     }
   }
 
-
   async upsert(updateModuleMetadataDto: UpdateModuleMetadataDto) {
     this.logger.log(`Module Upsert called for : ${updateModuleMetadataDto.name}`);
     // First check if module already exists using name
@@ -308,9 +306,6 @@ export class ModuleMetadataService {
     }
   }
 
-
-
-
   async removeByName(name: string) {
     const entity = await this.findOneByUserKey(name);
     if (entity) {

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

@@ -1,11 +1,10 @@
-import { Injectable } from "@nestjs/common";
+import { Injectable, Logger } from "@nestjs/common";
 import { DashboardQuestionDataProvider } from "src/decorators/dashboard-question-data-provider.decorator";
-import { Question } from "src/entities/question.entity";
+import { DashboardQuestion } from "src/entities/dashboard-question.entity";
 import { IDashboardQuestionDataProvider } from "src/interfaces";
 import { EntityManager } from "typeorm";
 import { SqlExpressionResolverService } from "../sql-expression-resolver.service";
-import { Logger } from '@nestjs/common';
-import { getLabels } from "./helpers";
+import { getKpi, getLabels } from "./helpers";
 
 export interface QuestionSqlDataProviderContext {
     // questionSqlDatasetConfig: QuestionSqlDatasetConfig;
@@ -50,7 +49,7 @@ export class ChartJsSqlDataProvider implements IDashboardQuestionDataProvider<Qu
         return "ChartJsSqlDataProvider";
     }
 
-    async getData(question: Question, expressions?: SqlExpression[], context?: QuestionSqlDataProviderContext): Promise<any> {
+    async getData(question: DashboardQuestion, 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.
@@ -80,7 +79,8 @@ export class ChartJsSqlDataProvider implements IDashboardQuestionDataProvider<Qu
         let datasetIdx = 0;
         const datasets = [];
 
-        const labels: string[] = await getLabels(question, this.entityManager);
+        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) {
@@ -91,8 +91,8 @@ export class ChartJsSqlDataProvider implements IDashboardQuestionDataProvider<Qu
             }
 
             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)}]`);
+            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.
@@ -111,8 +111,12 @@ export class ChartJsSqlDataProvider implements IDashboardQuestionDataProvider<Qu
         }
 
         return {
-            labels,
-            datasets
+            kpi,
+            visualizedAs: question.visualisedAs,
+            visualizationData: {
+                labels,
+                datasets
+            }
         };
 
     }

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

@@ -1,11 +1,30 @@
-import { Question } from "src/entities/question.entity";
+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: Question, entityManager: EntityManager): Promise<string[]> {
-    const labelSql = question.labelSql;
-    const labelResults = await this.entityManager.query(labelSql);
+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 || "";
 }

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

@@ -1,11 +1,12 @@
 import { Injectable } from "@nestjs/common";
 import { DashboardQuestionDataProvider } from "src/decorators/dashboard-question-data-provider.decorator";
-import { Question } from "src/entities/question.entity";
+import { DashboardQuestion } from "src/entities/dashboard-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";
+import { getKpi } from "./helpers";
 
 export interface QuestionSqlDataProviderContext {
     // questionSqlDatasetConfig: QuestionSqlDatasetConfig;
@@ -28,11 +29,12 @@ export class PrimeReactDatatableSqlDataProvider implements IDashboardQuestionDat
         return "PrimeReactDatatableSqlDataProvider";
     }
 
-    async getData(question: Question, expressions?: SqlExpression[], context?: QuestionSqlDataProviderContext): Promise<any> {
+    async getData(question: DashboardQuestion, 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 
 
         // Check the expected response for prime react data tables to understand what is going on here...
 
+        const kpi: string = await getKpi(question, expressions, this.entityManager, this.sqlExpressionResolver);
         // TODO: Load the set of labels by using a separate field on the question entity.
         const labelSql = question.labelSql;
         const labelResults = await this.entityManager.query(labelSql);
@@ -59,13 +61,17 @@ export class PrimeReactDatatableSqlDataProvider implements IDashboardQuestionDat
         }
 
         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)}]`);
+        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);
 
         return {
-            columns,
-            data: results,
+            kpi,
+            visualisedAs: question.visualisedAs,
+            visualizationData: {
+                columns,
+                rows: results,
+            }
         };
 
     }