@solidstarters/solid-core 1.2.133 → 1.2.135

package/src/helpers/field-crud-managers/SelectionDynamicFieldCrudManager.ts

@@ -20,31 +20,57 @@ export class SelectionDynamicFieldCrudManager implements FieldCrudManager {
 
     async validate(dto: any): Promise<ValidationError[]> {
         const fieldValue: any = dto[this.options.fieldName];
+        // return this.applyValidations(fieldValue);
         const isMultiSelect = this.options?.isMultiSelect;
+        if (isMultiSelect && fieldValue) {
+            const arrayCheck = this.parseAndValidateArray(fieldValue);
 
-        // return this.applyValidations(fieldValue);
-        // Handle multi-select scenario
-    if (isMultiSelect) {
-        let values: any[];
+            if (!arrayCheck.isValid) {
+                return [
+                    {
+                        field: this.options.fieldName,
+                        error: `Field: ${this.options.fieldName} must be a valid array`,
+                    },
+                ];
+            }
 
-        try {
-            // Try to parse the field value, which should be a JSON stringified array
-            values = JSON.parse(fieldValue);
-        } catch {
-            // If parsing fails, fallback to a single value
-            values = [fieldValue];
-        }
+            const values = arrayCheck.values;
 
-        // Apply validations to each value asynchronously
-        const allErrors = await Promise.all(values.map(value => this.applyValidations(value)));
+            if (this.isApplyRequiredValidation() && values.length === 0) {
+                return [
+                    {
+                        field: this.options.fieldName,
+                        error: `Field: ${this.options.fieldName} is required`,
+                    },
+                ];
+            }
 
-        // Flatten the array of errors and return
-        return allErrors.flat();
-    } else {
-        // For non-multi-select, apply validations to the single field value
-        return this.applyValidations(fieldValue);
+            // Apply validations to each value
+            const allErrors = await Promise.all(values.map((val) => this.applyValidations(val)));
+            return allErrors.flat();
+        } else {
+            // For non-multi-select, apply validations to the single field value
+            return this.applyValidations(fieldValue);
+        }
     }
+
+    private parseAndValidateArray(fieldValue: any): { isValid: boolean; values: any[] } {
+        if (Array.isArray(fieldValue)) {
+            return { isValid: true, values: fieldValue };
+        }
+    
+        try {
+            const parsed = typeof fieldValue === 'string' ? JSON.parse(fieldValue) : null;
+            if (Array.isArray(parsed)) {
+                return { isValid: true, values: parsed };
+            }
+        } catch {
+            // fall through
+        }
+    
+        return { isValid: false, values: [] };
     }
+    
 
     private async applyValidations(fieldValue: any): Promise<ValidationError[]> {
         const errors: ValidationError[] = [];

package/src/helpers/field-crud-managers/SelectionStaticFieldCrudManager.ts

@@ -16,24 +16,34 @@ export class SelectionStaticFieldCrudManager implements FieldCrudManager {
     }
 
     async validate(dto: any): Promise<ValidationError[]> {
-         const fieldValue: any = dto[this.options.fieldName];
+        const fieldValue: any = dto[this.options.fieldName];
         // return this.applyValidations(fieldValue);
         const isMultiSelect = this.options?.isMultiSelect;
-        if (isMultiSelect) {
-            let values: any[];
-    
-            try {
-                // Try to parse the field value, which should be a JSON stringified array
-                values = JSON.parse(fieldValue);
-            } catch {
-                // If parsing fails, fallback to a single value
-                values = [fieldValue];
+        if (isMultiSelect && fieldValue) {
+            const arrayCheck = this.parseAndValidateArray(fieldValue);
+
+            if (!arrayCheck.isValid) {
+                return [
+                    {
+                        field: this.options.fieldName,
+                        error: `Field: ${this.options.fieldName} must be a valid array`,
+                    },
+                ];
             }
-    
-            // Apply validations to each value asynchronously
-            const allErrors = await Promise.all(values.map(value => this.applyValidations(value)));
-    
-            // Flatten the array of errors and return
+
+            const values = arrayCheck.values;
+
+            if (this.isApplyRequiredValidation() && values.length === 0) {
+                return [
+                    {
+                        field: this.options.fieldName,
+                        error: `Field: ${this.options.fieldName} is required`,
+                    },
+                ];
+            }
+
+            // Apply validations to each value
+            const allErrors = await Promise.all(values.map((val) => this.applyValidations(val)));
             return allErrors.flat();
         } else {
             // For non-multi-select, apply validations to the single field value
@@ -41,6 +51,24 @@ export class SelectionStaticFieldCrudManager implements FieldCrudManager {
         }
     }
 
+    private parseAndValidateArray(fieldValue: any): { isValid: boolean; values: any[] } {
+        if (Array.isArray(fieldValue)) {
+            return { isValid: true, values: fieldValue };
+        }
+    
+        try {
+            const parsed = typeof fieldValue === 'string' ? JSON.parse(fieldValue) : null;
+            if (Array.isArray(parsed)) {
+                return { isValid: true, values: parsed };
+            }
+        } catch {
+            // fall through
+        }
+    
+        return { isValid: false, values: [] };
+    }
+    
+
     private applyValidations(fieldValue: any): ValidationError[] {
         const errors: ValidationError[] = [];
         this.isApplyRequiredValidation() && isEmpty(fieldValue) ? errors.push({ field: this.options.fieldName, error: `Field: ${this.options.fieldName} is required` }) : "no errors";

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/question.entity'
+export * from './entities/question-sql-dataset-config.entity'
+export * from './entities/ai-interaction.entity'
 
 export * from './enums/auth-type.enum'
 

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 { Question } from './entities/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,40 @@ 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 ISelectionProviderContext {
@@ -81,6 +82,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: Question, expressions?: SqlExpression[], ctxt?: TContext): Promise<TData[] | TData>;
+}
+
 /**
  * @deprecated Use `IEntityComputedFieldProvider` instead.
  */
@@ -94,7 +106,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 +134,7 @@ export class EventDetails<T> {
   constructor(
     public type: any,
     public payload: T,
-  ) {}
+  ) { }
 }
 
 export interface IMail {

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,100 @@
+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 { QuestionSqlDatasetConfig } from "src/entities/question-sql-dataset-config.entity";
+import { Question } from "src/entities/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: CreateDashboardDto) {
+        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'],
+        });
+
+        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 ?? {}),
+                })),
+            })),
+        };
+
+        if (existingDashboard) {
+            // Optionally clean up stale children
+            await this.cleanupRemovedRelations(existingDashboard, createDto);
+
+            this.merge(existingDashboard, dashboardData);
+            return this.save(existingDashboard);
+        } else {
+            const newDashboard = this.create(dashboardData);
+            return this.save(newDashboard);
+        }
+    }
+
+    private async cleanupRemovedRelations(existing: Dashboard, dto: CreateDashboardDto) {
+        const dashboardVariableRepo = this.dataSource.getRepository(DashboardVariable);
+        const questionRepo = this.dataSource.getRepository(Question);
+        const datasetConfigRepo = this.dataSource.getRepository(QuestionSqlDatasetConfig); // 👈 make sure this is imported
+
+        // === 1. Clean up removed dashboardVariables ===
+        const dtoVariableNames = new Set(dto.dashboardVariables.map(v => v.variableName));
+        const variablesToRemove = existing.dashboardVariables.filter(
+            v => !dtoVariableNames.has(v.variableName)
+        );
+        if (variablesToRemove.length > 0) {
+            await dashboardVariableRepo.remove(variablesToRemove);
+        }
+
+        // === 2. Clean up removed questions and gather removed question IDs ===
+        const dtoQuestionNames = new Set(dto.questions.map(q => q.name));
+        const questionsToRemove = existing.questions.filter(
+            q => !dtoQuestionNames.has(q.name)
+        );
+
+        if (questionsToRemove.length > 0) {
+            await questionRepo.remove(questionsToRemove);
+        }
+
+        // === 3. Clean up removed questionSqlDatasetConfigs from existing (retained) questions ===
+        for (const existingQuestion of existing.questions) {
+            const dtoQuestion = dto.questions.find(q => q.name === existingQuestion.name);
+            if (!dtoQuestion) continue;
+
+            const dtoDatasetNames = new Set(dtoQuestion.questionSqlDatasetConfigs?.map(cfg => cfg.datasetName));
+            const configsToRemove = existingQuestion.questionSqlDatasetConfigs.filter(
+                cfg => !dtoDatasetNames.has(cfg.datasetName)
+            );
+
+            if (configsToRemove.length > 0) {
+                await datasetConfigRepo.remove(configsToRemove);
+            }
+        }
+    }
+}

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);
+        }
+    }
+
 }