@solidstarters/solid-core 1.2.134 → 1.2.135

package/src/services/1. Create a context menu option i.py

@@ -0,0 +1,12 @@
+1. Create a context menu option i.e Custom Import
+2. On clicking custom import, we will show the wizard i.e (which will show the sample format links)
+2.1 No need to add any description for now
+2.1 For the sample import endpoint, we will create endpoint like import-template/custom/:format in qb controller, which will just return the saved template file from the media-storage-folder.
+3. On clicking continue on step 2, we will show the upload dialog
+4. On clicking upload, we will call the custom import endpoint
+4.1 start-import/custom/sync (body -> file)
+4.2 basis the mime type, we will call the call appropriate method to read the records from the file
+-> refer importFromFileToDB
+4.3 After reading the records, we will have the json for a particular records
+4.4. We will use this json to create the appropriate entities and save the record.
+4.5 You can use entity manager for saving the entity accordingly.

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

@@ -0,0 +1,127 @@
+import { BadRequestException, Injectable } from '@nestjs/common';
+import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
+import { DiscoveryService, ModuleRef } from "@nestjs/core";
+import { EntityManager, Repository } from 'typeorm';
+
+import { CRUDService } from 'src/services/crud.service';
+import { ModelMetadataService } from 'src/services/model-metadata.service';
+import { ModuleMetadataService } from 'src/services/module-metadata.service';
+import { ConfigService } from '@nestjs/config';
+import { FileService } from 'src/services/file.service';
+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[];
+}
+
+@Injectable()
+export class AiInteractionService extends CRUDService<AiInteraction> {
+  constructor(
+    readonly modelMetadataService: ModelMetadataService,
+    readonly moduleMetadataService: ModuleMetadataService,
+    readonly configService: ConfigService,
+    readonly fileService: FileService,
+    readonly discoveryService: DiscoveryService,
+    readonly crudHelperService: CrudHelperService,
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    @InjectRepository(AiInteraction, 'default')
+    readonly repo: Repository<AiInteraction>,
+    readonly moduleRef: ModuleRef
+
+  ) {
+    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'aiInteraction', 'solid-core', moduleRef);
+  }
+
+  /**
+   * 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> {
+    const pythonExecutable = process.env.MCP_PYTHON_EXECUTABLE;
+    const mcpClient = process.env.MCP_CLIENT;
+
+    // TODO: We can return an error if the above env variables are not properly setup...
+    if (!pythonExecutable || !mcpClient) {
+      throw new BadRequestException('SolidX AI MCP python executable or client path not configured.');
+    }
+
+    // Check if both paths are valid and accessible
+    try {
+      const [pyStat, clientStat] = await Promise.all([
+        fs.stat(pythonExecutable),
+        fs.stat(mcpClient),
+      ]);
+
+      if (!pyStat.isFile()) {
+        throw new BadRequestException(`MCP_PYTHON_EXECUTABLE path is not a file: ${pythonExecutable}`);
+      }
+
+      if (!clientStat.isFile()) {
+        throw new BadRequestException(`MCP_CLIENT path is not a file: ${mcpClient}`);
+      }
+
+    } catch (err: any) {
+      throw new BadRequestException(`Invalid MCP executable or client path: ${err.message}`);
+    }
+
+    return new Promise((resolve, reject) => {
+
+      const python = spawn(pythonExecutable, [mcpClient, prompt]);
+
+      let stdout = '';
+      let stderr = '';
+
+      python.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      python.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      python.on('close', (code) => {
+        if (code !== 0) {
+          return reject(new Error(`Python script exited with code ${code}: ${stderr}`));
+        }
+
+        try {
+          const raw: McpResponse = JSON.parse(stdout);
+
+          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();
+          }
+
+          const parsed = JSON.parse(cleaned);
+          resolve(parsed);
+        } catch (err: any) {
+          reject(new Error(`Failed to parse JSON: ${err.message}`));
+        }
+      });
+    });
+  }
+
+}

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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,36 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { DiscoveryService, ModuleRef } from "@nestjs/core";
+import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
+import { EntityManager, Repository } from 'typeorm';
+
+import { ConfigService } from '@nestjs/config';
+import { CrudHelperService } from 'src/services/crud-helper.service';
+import { CRUDService } from 'src/services/crud.service';
+import { FileService } from 'src/services/file.service';
+import { ModelMetadataService } from 'src/services/model-metadata.service';
+import { ModuleMetadataService } from 'src/services/module-metadata.service';
+
+
+import { DashboardVariable } from '../entities/dashboard-variable.entity';
+
+@Injectable()
+export class DashboardVariableService extends CRUDService<DashboardVariable> {
+  private readonly logger = new Logger(this.constructor.name);
+  constructor(
+    readonly modelMetadataService: ModelMetadataService,
+    readonly moduleMetadataService: ModuleMetadataService,
+    readonly configService: ConfigService,
+    readonly fileService: FileService,
+    readonly discoveryService: DiscoveryService,
+    readonly crudHelperService: CrudHelperService,
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    @InjectRepository(DashboardVariable, 'default')
+    readonly repo: Repository<DashboardVariable>,
+    readonly moduleRef: ModuleRef,
+  ) {
+    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'dashboardVariable', 'solid-core', moduleRef);
+  }
+
+
+}

package/src/services/dashboard.service.ts

@@ -0,0 +1,147 @@
+import { Injectable, Logger, NotFoundException } from '@nestjs/common';
+import { DiscoveryService, ModuleRef } from "@nestjs/core";
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { EntityManager } from 'typeorm';
+
+import { ConfigService } from '@nestjs/config';
+import { CrudHelperService } from 'src/services/crud-helper.service';
+import { CRUDService } from 'src/services/crud.service';
+import { FileService } from 'src/services/file.service';
+import { ModelMetadataService } from 'src/services/model-metadata.service';
+import { ModuleMetadataService } from 'src/services/module-metadata.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';
+
+
+export const SQL_DYNAMIC_PROVIDER_NAME = 'DashboardVariableSQLDynamicProvider';
+@Injectable()
+export class DashboardService extends CRUDService<Dashboard> {
+  private readonly logger = new Logger(this.constructor.name);
+  constructor(
+    readonly modelMetadataService: ModelMetadataService,
+    readonly moduleMetadataService: ModuleMetadataService,
+    readonly configService: ConfigService,
+    readonly fileService: FileService,
+    readonly discoveryService: DiscoveryService,
+    readonly crudHelperService: CrudHelperService,
+    @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(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'dashboard', 'solid-core', moduleRef);
+  }
+
+  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) {
+      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) {
+      const dashboardIndex = metaData.dashboards?.findIndex((dashboardFromFile: { name: string; }) => dashboardFromFile.name === dashboard.name);
+      const dto = await this.dashboardMapper.toDto(dashboard);
+      metaData.dashboards[dashboardIndex] = 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/menu-item-metadata.service.ts

@@ -169,7 +169,8 @@ export class MenuItemMetadataService extends CRUDService<MenuItemMetadata> {
           // TODO: Here we are assuming that we will always take the user to collection view of a model. 
           // We can make provision to take them other views also in the future. 
           // path = `/admin/core/${rootItem.module.name}/${rootItem.action.model.singularName}/${rootItem.action.view.name}`;
-          path = `/admin/core/${rootItem.module.name}/${dasherize(rootItem.action.model.singularName)}/${rootItem.action.view.type}`;
+          path = `/admin/core/${rootItem.module.name}/${dasherize(rootItem.action?.model?.singularName ?? 'unknown')}/${rootItem.action?.view?.type ?? 'list'}`;
+
         }
       }
 

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

@@ -0,0 +1,121 @@
+import { Injectable } from "@nestjs/common";
+import { DashboardQuestionDataProvider } from "src/decorators/dashboard-question-data-provider.decorator";
+import { Question } from "src/entities/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";
+
+export interface QuestionSqlDataProviderContext {
+    // questionSqlDatasetConfig: QuestionSqlDatasetConfig;
+    // questionId: number;
+    // question: Question;
+}
+
+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: Question, 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.
+        // 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, this.entityManager);
+
+        // 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.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)}]`);
+            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 {
+            labels,
+            datasets
+        };
+
+    }
+
+
+}

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

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

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

@@ -0,0 +1,72 @@
+import { Injectable } from "@nestjs/common";
+import { DashboardQuestionDataProvider } from "src/decorators/dashboard-question-data-provider.decorator";
+import { Question } from "src/entities/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";
+
+export interface QuestionSqlDataProviderContext {
+    // questionSqlDatasetConfig: QuestionSqlDatasetConfig;
+    // questionId: number;
+    // question: Question;
+}
+
+@DashboardQuestionDataProvider()
+@Injectable()
+export class PrimeReactDatatableSqlDataProvider implements IDashboardQuestionDataProvider<QuestionSqlDataProviderContext, any> {
+    private readonly logger = new Logger(PrimeReactDatatableSqlDataProvider.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 "PrimeReactDatatableSqlDataProvider";
+    }
+
+    async getData(question: Question, 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...
+
+        // 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);
+        const columns = [];
+        for (let i = 0; i < labelResults.length; i++) {
+            const labelResult = labelResults[i];
+            columns.push({
+                field: labelResult['field'],
+                header: labelResult['header'],
+            });
+        }
+
+        // Load the chart options as a JSON 
+        // const chartOptions = JSON.parse(question.barChartLabelOptions || '{}');
+
+        const values = []
+
+        // For meter group we can assume that we only have one sql dataset config.
+        const questionSqlDatasetConfig = question.questionSqlDatasetConfigs[0];
+
+        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.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)}]`);
+        const results = await this.entityManager.query(sqlReplacementResult.rawSql, sqlReplacementResult.parameters);
+
+        return {
+            columns,
+            data: results,
+        };
+
+    }
+}