@solidstarters/solid-core 1.2.135 → 1.2.136

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,15 @@ 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';
 
 @Injectable()
 export class AiInteractionService extends CRUDService<AiInteraction> {
+  private readonly logger = new Logger(AiInteractionService.name);
+
   constructor(
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
@@ -39,18 +32,45 @@ 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,
 
   ) {
     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,7 +98,10 @@ 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]);
 
@@ -94,34 +117,47 @@ 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(', ')}`));
-          }
-
-          let cleaned = raw.response.trim();
+          // if (!raw.success) {
+          //   return reject(new Error(`MCP error: ${raw.errors?.join(', ')}`));
+          // }
+          // let cleaned = raw.response.trim();
 
-          // Remove markdown-style code block wrapper
-          if (cleaned.startsWith('```json')) {
-            cleaned = cleaned.replace(/^```json/, '').trim();
-          }
-          if (cleaned.endsWith('```')) {
-            cleaned = cleaned.replace(/```$/, '').trim();
-          }
+          // Don't need to re-parse this...
+          // const parsed = JSON.parse(cleaned);
+          // resolve(cleaned);
 
-          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;
+  }
+
 }

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/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,
+            }
         };
 
     }

package/src/services/question-data-providers/prime-react-meter-group-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;
@@ -57,7 +58,7 @@ export class PrimeReactMeterGroupSqlDataProvider implements IDashboardQuestionDa
         return colors;
     }
 
-    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.
@@ -70,6 +71,8 @@ export class PrimeReactMeterGroupSqlDataProvider implements IDashboardQuestionDa
 
         // TODO: Load the set of labels by using a separate field on the question entity.
 
+        const kpi: string = await getKpi(question, expressions, this.entityManager, this.sqlExpressionResolver);
+        
         // Load the chart options as a JSON 
         const chartOptions = JSON.parse(question.chartOptions || '{}');
 
@@ -84,8 +87,8 @@ export class PrimeReactMeterGroupSqlDataProvider implements IDashboardQuestionDa
         }
 
         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);
 
         const colors = this.generateDistinctColors(results.length);
@@ -104,7 +107,13 @@ export class PrimeReactMeterGroupSqlDataProvider implements IDashboardQuestionDa
             })
         }
 
-        return values;
+        return {
+            kpi,
+            visualizedAs: question.visualisedAs,
+            visualizationData: {
+                dataset: values
+            },
+        };
 
     }
 }

package/src/services/question-data-providers/test.sql

@@ -0,0 +1 @@
+SELECT  TO_CHAR(DATE_TRUNC('month', created_at), 'Mon-YYYY') AS label,FROM  public.sapphire_clientwhere   created_at >= $1  GROUP BY   DATE_TRUNC('month', created_at) ORDER BY   DATE_TRUNC('month', created_at)

package/src/services/queues/publisher-factory.service.ts

@@ -16,7 +16,7 @@ export class PublisherFactory<T> {
     }
 
     async publish(message: QueueMessage<T>, publisherName: string, brokerToUse?: string): Promise<string> {
-        let defaultBrokerToUse = brokerToUse || process.env.QUEUES_DEFAULT_BROKER;
+        let defaultBrokerToUse = brokerToUse || process.env.QUEUES_DEFAULT_BROKER || "database";
         let resolvedPublisherName = `${publisherName}${classify(defaultBrokerToUse)}`;
 
         // Register all ISolidDatabaseModules implementations