@solidstarters/solid-core 1.2.134 → 1.2.136

package/src/helpers/solid-registry.ts

@@ -5,7 +5,7 @@ import { CommonEntity } from 'src/entities/common.entity';
 import { Locale } from 'src/entities/locale.entity';
 import { SecurityRule } from 'src/entities/security-rule.entity';
 import { IScheduledJob } from 'src/services/scheduled-jobs/scheduled-job.interface';
-import { ISelectionProvider, ISelectionProviderContext } from "../interfaces";
+import { IDashboardQuestionDataProvider, IDashboardVariableSelectionProvider, ISelectionProvider, ISelectionProviderContext } from "../interfaces";
 
 type ControllerMetadata = {
   name: string;
@@ -63,6 +63,8 @@ export class SolidRegistry {
   private securityRules: SecurityRule[] = [];
   private locales: Locale[] = [];
   private computedFieldMetadata: ComputedFieldMetadata[] = [];
+  private dashboardVariableSelectionProviders: Set<InstanceWrapper> = new Set();
+  private dashboardQuestionDataProviders: Set<InstanceWrapper> = new Set();
 
   registerController(name: string, methodNames: string[]): void {
     this.controllers.add({ name: name, methods: methodNames });
@@ -80,6 +82,14 @@ export class SolidRegistry {
     this.selectionProviders.add(selectionProvider);
   }
 
+  registerDashboardVariableSelectionProvider(dashboardSelectionProvider: InstanceWrapper): void {
+    this.dashboardVariableSelectionProviders.add(dashboardSelectionProvider);
+  }
+
+  registerDashboardQuestionDataProvider(dashboardQuestionDataProvider: InstanceWrapper): void {
+    this.dashboardQuestionDataProviders.add(dashboardQuestionDataProvider);
+  }
+
   registerComputedFieldProvider(computedFieldProvider: InstanceWrapper): void {
     this.computedFieldProviders.add(computedFieldProvider);
   }
@@ -119,6 +129,38 @@ export class SolidRegistry {
     }
   }
 
+  getDashboardVariableSelectionProviders(): Array<InstanceWrapper> {
+    return Array.from(this.dashboardVariableSelectionProviders);
+  }
+
+  getDashboardVariableSelectionProviderInstance<T extends ISelectionProviderContext>(name: string): IDashboardVariableSelectionProvider<T> {
+    const dashboardSelectionProviders = this.getDashboardVariableSelectionProviders();
+
+    for (let i = 0; i < dashboardSelectionProviders.length; i++) {
+      const dashboardSelectionProvider = dashboardSelectionProviders[i];
+      if (dashboardSelectionProvider.instance.name() === name) {
+        return dashboardSelectionProvider.instance;
+      }
+    }
+  }
+
+  getDashboardQuestionDataProviders(): Array<InstanceWrapper> {
+    return Array.from(this.dashboardQuestionDataProviders)
+  }
+
+  getDashboardQuestionDataProviderInstance<TContext, TData>(name: string): IDashboardQuestionDataProvider<TContext, TData> {
+    const dashboardQuestionDataProviders = this.getDashboardQuestionDataProviders();
+
+    for (let i = 0; i < dashboardQuestionDataProviders.length; i++) {
+      const dasbhoardQuestionDataProvider = dashboardQuestionDataProviders[i];
+      if (dasbhoardQuestionDataProvider.instance.name() === name) {
+        return dasbhoardQuestionDataProvider.instance;
+      }
+    }
+
+  }
+
+
   getComputedFieldProviders(): Array<InstanceWrapper> {
     return Array.from(this.computedFieldProviders);
   }
@@ -137,7 +179,7 @@ export class SolidRegistry {
       }
     }
   }
-  
+
   getComputedFieldProvider(name: string): InstanceWrapper {
     const provider = this.getComputedFieldProviders().filter((provider) => provider.name === name).pop();
     if (!provider) {

package/src/index.ts

@@ -125,6 +125,11 @@ export * from './entities/import-transaction.entity'
 export * from './entities/import-transaction-error-log.entity'
 export * from './entities/locale.entity'
 export * from './entities/user-activity-history.entity'
+export * from './entities/dashboard.entity'
+export * from './entities/dashboard-variable.entity'
+export * from './entities/dashboard-question.entity'
+export * from './entities/dashboard-question-sql-dataset-config.entity'
+export * from './entities/ai-interaction.entity'
 
 export * from './enums/auth-type.enum'
 
@@ -159,7 +164,7 @@ export * from './helpers/field-crud-managers/SelectionDynamicFieldCrudManager' /
 export * from './helpers/field-crud-managers/SelectionStaticFieldCrudManager' //rename
 export * from './helpers/field-crud-managers/ShortTextFieldCrudManager' //rename
 export * from './helpers/field-crud-managers/UUIDFieldCrudManager' //rename
-
+export * from './services/crud.service'
 export * from './interceptors/logging.interceptor'
 export * from './interceptors/wrap-response.interceptor'
 
@@ -248,7 +253,10 @@ export * from './services/chatter-message.service'
 export * from './services/chatter-message-details.service'
 export * from './services/locale.service'
 export * from './services/user-activity-history.service'
-
+export * from './services/import-transaction.service'
+export * from './services/import-transaction-error-log.service'
+export * from './services/excel.service'
+export * from './services/csv.service'
 // Repositories
 export * from './repository/solid-base.repository'
 export * from './repository/security-rule.repository'

package/src/interfaces.ts

@@ -1,18 +1,18 @@
 import { CreateEmailTemplateDto } from 'src/dtos/create-email-template.dto';
 import { CreateSmsTemplateDto } from 'src/dtos/create-sms-template.dto';
 import { SignUpDto } from 'src/dtos/sign-up.dto';
-import { CreateActionMetadataDto } from './dtos/create-action-metadata.dto';
+import { Readable } from 'stream';
 import { CreateMediaStorageProviderMetadataDto } from './dtos/create-media-storage-provider-metadata.dto';
-import { CreateMenuItemMetadataDto } from './dtos/create-menu-item-metadata.dto';
 import { DatasourceType } from './dtos/create-model-metadata.dto';
 import { CreateModuleMetadataDto } from './dtos/create-module-metadata.dto';
 import { CreateRoleMetadataDto } from './dtos/create-role-metadata.dto';
 import { CreateSecurityRuleDto } from './dtos/create-security-rule.dto';
-import { CreateViewMetadataDto } from './dtos/create-view-metadata.dto';
 import { FieldMetadata } from './entities/field-metadata.entity';
 import { Media } from './entities/media.entity';
-import { Readable } from 'stream';
+import { DashboardQuestion } from './entities/dashboard-question.entity';
 import { ComputedFieldMetadata } from './helpers/solid-registry';
+import { SqlExpression } from './services/question-data-providers/chartjs-sql-data-provider.service';
+import { CreateDashboardDto } from './dtos/create-dashboard.dto';
 
 export interface FieldCrudManager {
   // fieldMetadata: FieldMetadata;
@@ -27,39 +27,56 @@ export interface FieldCrudManager {
 }
 
 export interface ValidationError {
-    field: string;
-    error: string;
+  field: string;
+  error: string;
 }
 
 // export interface MediaStorage
 export interface MediaStorageProvider<T> {
-    store(files: Express.Multer.File[], entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]>;
-    delete(entity: T, mediaFieldMetadata: FieldMetadata): Promise<void>;
-    retrieve(entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]>;
-    storeStreams(streamPairs: [Readable, string][], entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]>;
-    // delete(file: string): Promise<void>;
+  store(files: Express.Multer.File[], entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]>;
+  delete(entity: T, mediaFieldMetadata: FieldMetadata): Promise<void>;
+  retrieve(entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]>;
+  storeStreams(streamPairs: [Readable, string][], entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]>;
+  // delete(file: string): Promise<void>;
 }
 
 export interface ModuleMetadataConfiguration {
-    moduleMetadata?: CreateModuleMetadataDto,
-    roles?: CreateRoleMetadataDto[],
-    users?: SignUpDto[],
-    actions?: any[],
-    menus?: any[],
-    views?: any[],
-    emailTemplates?: CreateEmailTemplateDto[],
-    smsTemplates?: CreateSmsTemplateDto[],
-    mediaStorageProviders?: CreateMediaStorageProviderMetadataDto[]
-    securityRules?: CreateSecurityRuleDto[],
+  moduleMetadata?: CreateModuleMetadataDto,
+  roles?: CreateRoleMetadataDto[],
+  users?: SignUpDto[],
+  actions?: any[],
+  menus?: any[],
+  views?: any[],
+  emailTemplates?: CreateEmailTemplateDto[],
+  smsTemplates?: CreateSmsTemplateDto[],
+  mediaStorageProviders?: CreateMediaStorageProviderMetadataDto[]
+  securityRules?: CreateSecurityRuleDto[],
+  dashboards?: CreateDashboardDto[],
 }
 
 export interface CodeGenerationOptions {
-    moduleId?: number;
-    moduleUserKey?: string;
-    modelId?: number;
-    modelUserKey?: string;
-    fieldIdsForRemoval?: number[];
-    dryRun?: boolean;
+  moduleId?: number;
+  moduleUserKey?: string;
+  modelId?: number;
+  modelUserKey?: string;
+  fieldIdsForRemoval?: number[];
+  dryRun?: boolean;
+}
+
+export interface TriggerMcpClientOptions {
+  aiInteractionId: number;
+}
+
+export interface McpResponse {
+  success: boolean;
+  request: string;
+  response: string;
+  model?: string;
+  tools_invoked?: string[];
+  tool_calls?: any[];
+  duration_ms?: number;
+  errors?: string[];
+  trace?: string[];
 }
 
 export interface ISelectionProviderContext {
@@ -81,6 +98,17 @@ export interface ISelectionProvider<T extends ISelectionProviderContext> {
   values(query: any, ctxt: T): Promise<readonly ISelectionProviderValues[]>;
 }
 
+export interface IDashboardVariableSelectionProvider<T extends ISelectionProviderContext> extends ISelectionProvider<T> {
+}
+
+export interface IDashboardQuestionDataProvider<TContext, TData> {
+  help(): string;
+
+  name(): string;
+
+  getData(question: DashboardQuestion, expressions?: SqlExpression[], ctxt?: TContext): Promise<TData[] | TData>;
+}
+
 /**
  * @deprecated Use `IEntityComputedFieldProvider` instead.
  */
@@ -94,7 +122,7 @@ export interface IComputedFieldProvider<T> {
   computeValue(dto: any, ctxt: T): Promise<string | number>; // FIXME : Improve the types to make it more specific using generics
 }
 
-export interface IEntityComputedFieldProvider {  
+export interface IEntityComputedFieldProvider {
   help(): string;
 
   name(): string;
@@ -122,7 +150,7 @@ export class EventDetails<T> {
   constructor(
     public type: any,
     public payload: T,
-  ) {}
+  ) { }
 }
 
 export interface IMail {

package/src/jobs/database/trigger-mcp-client-publisher-database.service.ts

@@ -0,0 +1,22 @@
+import { Injectable } from "@nestjs/common";
+import { QueuesModuleOptions, TriggerMcpClientOptions } from "src/interfaces";
+import { MqMessageQueueService } from "src/services/mq-message-queue.service";
+import { MqMessageService } from "src/services/mq-message.service";
+import { DatabasePublisher } from "src/services/queues/database-publisher.service";
+import triggerMcpClientQueueOptions from "./trigger-mcp-client-queue-options";
+
+@Injectable()
+export class TriggerMcpClientPublisherDatabase extends DatabasePublisher<TriggerMcpClientOptions> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...triggerMcpClientQueueOptions
+        };
+    }
+}

package/src/jobs/database/trigger-mcp-client-queue-options.ts

@@ -0,0 +1,9 @@
+import { BrokerType } from "src/interfaces";
+
+const TRIGGER_MCP_CLIENT_QUEUE_NAME = 'trigger_mcp_client_queue';
+
+export default {
+    name: 'triggerMcpClientQueue',
+    type: BrokerType.Database,
+    queueName: TRIGGER_MCP_CLIENT_QUEUE_NAME,
+};

package/src/jobs/database/trigger-mcp-client-subscriber-database.service.ts

@@ -0,0 +1,71 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { QueueMessage } from 'src/interfaces/mq';
+import { MqMessageService } from '../../services/mq-message.service';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { QueuesModuleOptions, TriggerMcpClientOptions } from "../../interfaces";
+import { DatabaseSubscriber } from 'src/services/queues/database-subscriber.service';
+import triggerMcpClientQueueOptions from "./trigger-mcp-client-queue-options";
+import { AiInteractionService } from 'src/services/ai-interaction.service';
+
+@Injectable()
+export class TriggerMcpClientSubscriberDatabase extends DatabaseSubscriber<TriggerMcpClientOptions> {
+    private readonly triggerMcpClientSubscriberLogger = new Logger(TriggerMcpClientSubscriberDatabase.name);
+
+    constructor(
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        readonly aiInteractionService: AiInteractionService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...triggerMcpClientQueueOptions
+        }
+    }
+
+    async subscribe(message: QueueMessage<TriggerMcpClientOptions>) {
+        this.triggerMcpClientSubscriberLogger.debug(`Received message: ${JSON.stringify(message)}`);
+
+        const codeGnerationOptions = message.payload;
+
+        const aiInteraction = await this.aiInteractionService.findOne(codeGnerationOptions.aiInteractionId, {
+            populate: ['user']
+        });
+
+        // The message contains the users prompt.
+        const prompt = aiInteraction.message;
+
+        // Use this to invoke our mcp client
+        const aiResponse = await this.aiInteractionService.runMcpPrompt(prompt);
+        let nestedResponse = aiResponse.response.trim();
+        if (!aiResponse.success) {
+            // update the job entry with success... raising an error will lead the job to be marked as failed...
+            throw new Error(aiResponse.errors.join(','));
+        }
+        else {
+            // TODO: create a new entry not update...
+            // const updatedDto = {
+            //     ...aiInteraction,
+            //     message: nestedResponse,
+            // }
+            // await this.aiInteractionService.update(codeGnerationOptions.aiInteractionId, updatedDto);
+
+            await this.aiInteractionService.create({
+                userId: aiInteraction.user.id,
+                threadId: aiInteraction.threadId,
+                role: 'gen-ai',
+                message: nestedResponse,
+                contentType: '',
+                errorMessage: '',
+                modelUsed: aiResponse.model,
+                responseTimeMs: aiResponse.duration_ms,
+                metadata: JSON.stringify(aiResponse)
+            })
+        }
+
+        return aiResponse;
+    }
+}

package/src/mappers/dashboard-mapper.ts

@@ -0,0 +1,52 @@
+import { Injectable } from "@nestjs/common";
+import { SelectionDynamicSourceType } from "src/dtos/create-dashboard-variable.dto";
+import { Dashboard } from "src/entities/dashboard.entity";
+
+@Injectable()
+export class DashboardMapper {
+    toDto(dashboard: Dashboard): any {
+        return {
+            name: dashboard.name,
+            layoutJson: this.safeParseJSON(dashboard.layoutJson, {}),
+            moduleUserKey: dashboard.module?.name ?? null, // safer fallback
+
+            dashboardVariables: (dashboard.dashboardVariables || []).map(variable => ({
+                variableName: variable.variableName,
+                variableType: variable.variableType,
+                selectionStaticValues: this.safeParseJSON(variable.selectionStaticValues, []),
+                selectionDynamicSourceType: variable.selectionDynamicSourceType as SelectionDynamicSourceType,
+                selectionDynamicSQL: variable.selectionDynamicSQL ?? null,
+                selectionDynamicProviderName: variable.selectionDynamicProviderName ?? null,
+                defaultValue: this.safeParseJSON(variable.defaultValue, []),
+                defaultOperator: variable.defaultOperator ?? null,
+            })),
+            questions: (dashboard.questions || []).map(question => ({
+                name: question.name,
+                sourceType: question.sourceType,
+                visualisedAs: question.visualisedAs,
+                providerName: question.providerName ?? null,
+                chartOptions: question.chartOptions ?? null,
+                labelSql: question.labelSql ?? null,
+                kpiSql: question.kpiSql ?? null,
+
+                questionSqlDatasetConfigs: (question.questionSqlDatasetConfigs || []).map(config => ({
+                    sql: config.sql,
+                    datasetName: config.datasetName,
+                    datasetDisplayName: config.datasetDisplayName, // 🔧 fixed typo: `daataSetDisplayName`
+                    description: config.description,
+                    labelColumnName: config.labelColumnName,
+                    valueColumnName: config.valueColumnName,
+                    options: this.safeParseJSON(config.options, {}),
+                }))
+            }))
+        };
+    }
+
+    private safeParseJSON(json: string | null | undefined, fallback: any): any {
+        try {
+            return json ? JSON.parse(json) : fallback;
+        } catch {
+            return fallback;
+        }
+    }
+}

package/src/repository/dashboard.repository.ts

@@ -0,0 +1,101 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { CreateDashboardDto } from "src/dtos/create-dashboard.dto";
+import { DashboardVariable } from "src/entities/dashboard-variable.entity";
+import { Dashboard } from "src/entities/dashboard.entity";
+import { ModuleMetadata } from "src/entities/module-metadata.entity";
+import { DashboardQuestionSqlDatasetConfig } from "src/entities/dashboard-question-sql-dataset-config.entity";
+import { DashboardQuestion } from "src/entities/dashboard-question.entity";
+import { DataSource, Repository } from "typeorm";
+
+@Injectable()
+export class DashboardRepository extends Repository<Dashboard> {
+    private readonly logger = new Logger(this.constructor.name);
+    constructor(
+        private dataSource: DataSource,
+    ) {
+        super(Dashboard, dataSource.createEntityManager());
+    }
+
+
+    async upsertWithDto(createDto: any) {
+        const moduleMetadataRepository = this.dataSource.getRepository(ModuleMetadata);
+        const module = await moduleMetadataRepository.findOneBy({ name: createDto.moduleUserKey });
+
+        if (!module) throw new Error(`Module with key ${createDto.moduleUserKey} not found`);
+
+        const existingDashboard = await this.findOne({
+            where: { name: createDto.name },
+            relations: ['dashboardVariables', 'questions', 'questions.questionSqlDatasetConfigs'],
+        });
+
+        if (existingDashboard) {
+            // Update basic fields
+            existingDashboard.layoutJson = JSON.stringify(createDto.layoutJson ?? {});
+            existingDashboard.module = module;
+
+            // Upsert dashboard variables
+            existingDashboard.dashboardVariables = createDto.dashboardVariables?.map(variable => {
+                const existingVar = existingDashboard.dashboardVariables.find(v => v.variableName === variable.variableName);
+                if (existingVar) {
+                    return Object.assign(existingVar, {
+                        ...variable,
+                        selectionStaticValues: JSON.stringify(variable.selectionStaticValues ?? []),
+                        defaultValue: JSON.stringify(variable.defaultValue ?? []),
+                    });
+                }
+                return {
+                    ...variable,
+                    selectionStaticValues: JSON.stringify(variable.selectionStaticValues ?? []),
+                    defaultValue: JSON.stringify(variable.defaultValue ?? []),
+                };
+            }) ?? [];
+
+            // Upsert questions and their configs
+            existingDashboard.questions = createDto.questions?.map(question => {
+                const existingQuestion = existingDashboard.questions.find(q => q.name === question.name);
+                const questionData: any = {
+                    ...question,
+                    questionSqlDatasetConfigs: question.questionSqlDatasetConfigs?.map(cfg => {
+                        const existingCfg = existingQuestion?.questionSqlDatasetConfigs.find(c => c.datasetName === cfg.datasetName);
+                        if (existingCfg) {
+                            return Object.assign(existingCfg, {
+                                ...cfg,
+                                options: JSON.stringify(cfg.options ?? {}),
+                            });
+                        }
+                        return {
+                            ...cfg,
+                            options: JSON.stringify(cfg.options ?? {}),
+                        };
+                    }) ?? [],
+                };
+
+                return existingQuestion ? Object.assign(existingQuestion, questionData) : questionData;
+            }) ?? [];
+
+            return this.save(existingDashboard);
+        }
+
+        // Else: new dashboard
+        const dashboardData = {
+            ...createDto,
+            module,
+            layoutJson: JSON.stringify(createDto.layoutJson ?? {}),
+            dashboardVariables: createDto.dashboardVariables?.map(variable => ({
+                ...variable,
+                selectionStaticValues: JSON.stringify(variable.selectionStaticValues ?? []),
+                defaultValue: JSON.stringify(variable.defaultValue ?? []),
+            })),
+            questions: createDto.questions?.map(question => ({
+                ...question,
+                questionSqlDatasetConfigs: question.questionSqlDatasetConfigs?.map(cfg => ({
+                    ...cfg,
+                    options: JSON.stringify(cfg.options ?? {}),
+                })),
+            })),
+        };
+
+        const newDashboard = this.create(dashboardData);
+        return this.save(newDashboard);
+    }
+}

package/src/seeders/module-metadata-seeder.service.ts

@@ -37,6 +37,8 @@ import { SecurityRuleRepository } from 'src/repository/security-rule.repository'
 import { ListOfValuesService } from 'src/services/list-of-values.service';
 import { CreateListOfValuesDto } from 'src/dtos/create-list-of-values.dto';
 import { SystemFieldsSeederService } from './system-fields-seeder.service';
+import { CreateDashboardDto } from 'src/dtos/create-dashboard.dto';
+import { DashboardRepository } from 'src/repository/dashboard.repository';
 
 @Injectable()
 export class ModuleMetadataSeederService {
@@ -69,7 +71,8 @@ export class ModuleMetadataSeederService {
         @InjectRepository(Setting, 'default')
         readonly settingsRepo: Repository<Setting>,
         readonly securityRuleRepo: SecurityRuleRepository,
-        readonly systemFieldsSeederService: SystemFieldsSeederService
+        readonly systemFieldsSeederService: SystemFieldsSeederService,
+        readonly dashboardRepo: DashboardRepository,
     ) { }
 
     async seed() {
@@ -212,6 +215,13 @@ export class ModuleMetadataSeederService {
             await this.seedListOfValues(listOfValues);
             this.logger.debug(`[End] Processing List Of Values for ${moduleMetadata.name}`);
 
+            // Dashboards
+            this.logger.debug(`[Start] Processing dashboards for ${moduleMetadata.name}`);
+            const dashboards: CreateDashboardDto[] = overallMetadata.dashboards;
+            await this.seedDashboards(dashboards);
+            this.logger.debug(`[End] Processing dashboards for ${moduleMetadata.name}`);
+
+
             this.logger.debug(`[End] module seed data: ${overallMetadata}`);
 
         }
@@ -559,4 +569,14 @@ export class ModuleMetadataSeederService {
         }
     }
 
+    async seedDashboards(dashboardDtos: CreateDashboardDto[]) {
+        if (!dashboardDtos || dashboardDtos.length === 0) {
+            this.logger.debug(`No dashboards found to seed`);
+            return;
+        }
+        for (const dto of dashboardDtos) {
+            await this.dashboardRepo.upsertWithDto(dto);
+        }
+    }
+
 }