@solidstarters/solid-core 1.2.134 → 1.2.136

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

@@ -0,0 +1,163 @@
+import { BadRequestException, Logger, 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 { 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,
+    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,
+    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<McpResponse> {
+    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}`);
+    }
+
+    // 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]);
+
+      let stdout = '';
+      let stderr = '';
+
+      python.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      python.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      python.on('close', (code) => {
+        this.logger.log(`Python script exited with code ${code}`);
+
+        if (code !== 0) {
+          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();
+
+          // Don't need to re-parse this...
+          // const parsed = JSON.parse(cleaned);
+          // resolve(cleaned);
+
+          resolve(raw);
+        } catch (err: any) {
+          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/dashboard-question-sql-dataset-config.service.ts

@@ -0,0 +1,34 @@
+import { 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 { DashboardQuestionSqlDatasetConfig } from '../entities/dashboard-question-sql-dataset-config.entity';
+
+@Injectable()
+export class DashboardQuestionSqlDatasetConfigService extends CRUDService<DashboardQuestionSqlDatasetConfig>{
+  constructor(
+    readonly modelMetadataService: ModelMetadataService,
+    readonly moduleMetadataService: ModuleMetadataService,
+    readonly configService: ConfigService,
+    readonly fileService: FileService,
+    readonly discoveryService: DiscoveryService,
+    readonly crudHelperService: CrudHelperService,
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    @InjectRepository(DashboardQuestionSqlDatasetConfig, 'default')
+    readonly repo: Repository<DashboardQuestionSqlDatasetConfig>,
+    readonly moduleRef: ModuleRef
+
+ ) {
+   super(modelMetadataService, moduleMetadataService,  configService, fileService,  discoveryService, crudHelperService,entityManager, repo, 'dashboardQuestionSqlDatasetConfig', 'solid-core', moduleRef);
+ }
+}

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

@@ -0,0 +1,115 @@
+import { BadRequestException, Injectable, Logger, NotImplementedException } 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 'src/entities/dashboard-variable.entity';
+import { SolidRegistry } from 'src/helpers/solid-registry';
+import { DashboardQuestion } from '../entities/dashboard-question.entity';
+import { SqlExpression, SqlExpressionOperator } from './question-data-providers/chartjs-sql-data-provider.service';
+import { DashboardService } from './dashboard.service';
+import { Dashboard } from 'src/entities/dashboard.entity';
+
+enum SOURCE_TYPE {
+  SQL = 'sql',
+  PROVIDER = 'provider',
+}
+
+const CHARTJS_SQL_DATA_PROVIDER_NAME = 'ChartJsSqlDataProvider';
+const PRIME_REACT_METER_GROUP_SQL_DATA_PROVIDER_NAME = 'PrimeReactMeterGroupSqlDataProvider';
+const PRIME_REACT_DATATABLE_SQL_DATA_PROVIDER_NAME = 'PrimeReactDatatableSqlDataProvider';
+
+@Injectable()
+export class DashboardQuestionService extends CRUDService<DashboardQuestion> {
+  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(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, 'dashboardQuestion', 'solid-core', moduleRef);
+  }
+
+  // Get the data for a specific question 
+  async getData(id: number, inputExpressions: SqlExpression[] = [], isPreview = false): Promise<any> {
+    // Load the question
+    const question = await this.loadQuestion(id);
+    if (!question) {
+      throw new BadRequestException(`Question with id ${id} not found`);
+    }
+
+    // Get the dashbbard variables from the question
+    const dashboardVariables = question.dashboard?.dashboardVariables || [];
+    const expressions: SqlExpression[] = this.getExpressions(isPreview, dashboardVariables, inputExpressions);
+
+    // Try to resolve the dataProvider based on a combination of sourceType and visualisedAs
+    let dataProvider = null;
+
+    if (question.sourceType === SOURCE_TYPE.SQL && ['bar', 'pie', 'line', 'donut'].includes(question.visualisedAs)) {
+      dataProvider = this.solidRegistry.getDashboardQuestionDataProviderInstance(CHARTJS_SQL_DATA_PROVIDER_NAME);
+    }
+    if (question.sourceType === SOURCE_TYPE.SQL && ['prime-meter-group'].includes(question.visualisedAs)) {
+      dataProvider = this.solidRegistry.getDashboardQuestionDataProviderInstance(PRIME_REACT_METER_GROUP_SQL_DATA_PROVIDER_NAME);
+    }
+    if (question.sourceType === SOURCE_TYPE.SQL && ['prime-datatable'].includes(question.visualisedAs)) {
+      dataProvider = this.solidRegistry.getDashboardQuestionDataProviderInstance(PRIME_REACT_DATATABLE_SQL_DATA_PROVIDER_NAME);
+    }
+
+    if (!dataProvider) {
+      throw new NotImplementedException(`Invalid data source type ${question.sourceType}`);
+    }
+
+    return await dataProvider.getData(question, expressions);
+
+  }
+
+  private getExpressions(isPreview: boolean, dashboardVariables: DashboardVariable[], inputExpressions: SqlExpression[]) {
+    const expressions: SqlExpression[] = [];
+    if (isPreview) {
+      // Convert the dashboard variables into objects of interface type SqlExpression using the default value, default operator and the variable name
+      const expr: SqlExpression[] = dashboardVariables.map(variable => {
+        return {
+          variableName: variable.variableName,
+          operator: variable.defaultOperator as SqlExpressionOperator, // Assuming defaultOperator is a valid SqlExpressionOperator
+          value: JSON.parse(variable.defaultValue || '[]'), // Assuming defaultValue is a string or can be converted to a string array
+        };
+      });
+      expressions.push(...expr);
+    }
+    else {
+      expressions.push(...inputExpressions);
+    }
+    return expressions;
+  }
+
+  private async loadQuestion(id: number) {
+    const repo = this.entityManager.getRepository(DashboardQuestion);
+
+    // Load the dashboard record using the field
+    const question = await repo.findOne({
+      where: {
+        id,
+      },
+      relations: ['questionSqlDatasetConfigs', 'dashboard', 'dashboard.dashboardVariables'],
+    });
+    return question;
+  }
+
+}

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

@@ -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/field-metadata.service.ts

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