@solidstarters/solid-core 1.2.137 → 1.2.139

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.137",
+  "version": "1.2.139",
   "description": "This module is a NestJS module containing all the required core providers required by a Solid application",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/dtos/create-dashboard-question.dto.ts

@@ -55,9 +55,8 @@ export class CreateDashboardQuestionDto {
     @IsString()
     @ApiProperty({ description: "This is the SQL query to fetch the KPI value for the question" })
     kpiSql: string;
-
-@IsOptional()
-@IsInt()
-@ApiProperty()
-sequenceNumber: number;
+    @IsOptional()
+    @IsInt()
+    @ApiProperty()
+    sequenceNumber: number;
 }

package/src/dtos/create-dashboard.dto.ts

@@ -50,4 +50,12 @@ export class CreateDashboardDto {
     @IsOptional()
     @ApiProperty()
     moduleUserKey: string;
+    @IsOptional()
+    @IsString()
+    @ApiProperty()
+    displayName: string;
+    @IsOptional()
+    @IsString()
+    @ApiProperty({ description: "This is a description of the dashboard configuration, providing context and details about the dashboard." })
+    description: string;
 }

package/src/dtos/update-dashboard-question.dto.ts

@@ -60,9 +60,8 @@ export class UpdateDashboardQuestionDto {
     @IsString()
     @ApiProperty({ description: "This is the SQL query to fetch the KPI value for the question" })
     kpiSql: string;
-
-@IsOptional()
-@IsInt()
-@ApiProperty()
-sequenceNumber: number;
+    @IsOptional()
+    @IsInt()
+    @ApiProperty()
+    sequenceNumber: number;
 }

package/src/dtos/update-dashboard.dto.ts

@@ -54,4 +54,12 @@ export class UpdateDashboardDto {
     @IsOptional()
     @ApiProperty()
     moduleUserKey: string;
+    @IsOptional()
+    @IsString()
+    @ApiProperty()
+    displayName: string;
+    @IsOptional()
+    @IsString()
+    @ApiProperty({ description: "This is a description of the dashboard configuration, providing context and details about the dashboard." })
+    description: string;
 }

package/src/entities/dashboard-question.entity.ts

@@ -27,7 +27,6 @@ export class DashboardQuestion extends CommonEntity {
     labelSql: string;
     @Column({ type: "text", nullable: true })
     kpiSql: string;
-
-@Column({ type: "integer", nullable: true })
-sequenceNumber: number;
+    @Column({ type: "integer", nullable: true })
+    sequenceNumber: number;
 }

package/src/entities/dashboard.entity.ts

@@ -18,4 +18,8 @@ export class Dashboard extends CommonEntity {
     @ManyToOne(() => ModuleMetadata, { onDelete: "CASCADE", nullable: false })
     @JoinColumn()
     module: ModuleMetadata;
+    @Column({ type: "varchar", nullable: true })
+    displayName: string;
+    @Column({ type: "text", nullable: true })
+    description: string;
 }

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

@@ -9,9 +9,10 @@ export interface ManyToOneRelationFieldOptions {
     required: boolean | undefined | null;
     relationCoModelSingularName: string | undefined | null;
     fieldName: string | undefined | null;
-    modelUserKeyFieldName: string | undefined | null;
+    // modelUserKeyFieldName: string | undefined | null;
     modelSingularName: string | undefined | null;
     entityManager: EntityManager;
+    relationCoModelUserKeyFieldName: string | undefined | null; 
 }
 
 // This implementation is meant to be used for many-to-one relation field
@@ -50,8 +51,8 @@ export class ManyToOneRelationFieldCrudManager implements FieldCrudManager {
     private applyUserKeyFormatValidations(fieldUserKey: string): ValidationError[] {
         const errors: ValidationError[] = [];
         !isString(fieldUserKey) ? errors.push({ field: this.options.fieldName, error: 'Field is not a string' }) : "no errors";
-        if (isEmpty(this.options.modelUserKeyFieldName)) {
-            errors.push({ field: this.options.fieldName, error: `UserKey field name is not defined in the model ${this.options.modelSingularName}` });
+        if (isEmpty(this.options.relationCoModelUserKeyFieldName)) {
+            errors.push({ field: this.options.fieldName, error: `UserKey field name is not defined in the model ${this.options.relationCoModelSingularName}` });
         }
         return errors;
     }
@@ -72,9 +73,9 @@ export class ManyToOneRelationFieldCrudManager implements FieldCrudManager {
             }
         }
         else {
-            dto[this.options.fieldName] = await this.options.entityManager.getRepository(entityTarget).findOneBy({ [this.options.modelUserKeyFieldName]: fieldUserKeyValue });
+            dto[this.options.fieldName] = await this.options.entityManager.getRepository(entityTarget).findOneBy({ [this.options.relationCoModelUserKeyFieldName]: fieldUserKeyValue });
             if (this.options.required && isEmpty(dto[this.options.fieldName])) {
-                throw new Error(`ManyToOneRelationFieldCrudManager: Record with userKey: ${this.options.modelUserKeyFieldName}: ${fieldUserKeyValue} not found in ${this.options.relationCoModelSingularName}`);
+                throw new Error(`ManyToOneRelationFieldCrudManager: Record with userKey: ${this.options.relationCoModelUserKeyFieldName}: ${fieldUserKeyValue} not found in ${this.options.relationCoModelSingularName}`);
             }
         }
 

package/src/helpers/module.helper.ts

@@ -3,23 +3,36 @@ import * as path from 'path'; // To handle file paths
 
 
 export const getDynamicModuleNames = (): string[] => {
-    const dynamicModulesToExclude = process.env.SOLID_DYNAMIC_MODULES_TO_EXCLUDE?.split(',') || [];
-  
-    // Adjust if 'src' is in a different location
-    const srcPath = path.join(process.cwd(), 'src');
-    const coreModuleNames = getCoreModuleNames();
-    const allExcludedModules = [...new Set([...coreModuleNames, ...dynamicModulesToExclude])];
-  
-    const directories = fs.readdirSync(srcPath, { withFileTypes: true });
-    const enabledModules = directories
-      .filter(d => d.isDirectory() && !allExcludedModules.includes(d.name))
-      .map(d => d.name);
-  
-    console.log(`Enabled dynamic modules:`, enabledModules);
-    return enabledModules;
-  }
-  
-  export const getCoreModuleNames = (): string[] => {
-    // return ['iam', 'common', 'queues', 'app-builder'];
-    return ['solid-core'];
-  }
+  const dynamicModulesToExclude = process.env.SOLID_DYNAMIC_MODULES_TO_EXCLUDE?.split(',') || [];
+
+  // Adjust if 'src' is in a different location
+  const srcPath = path.join(process.cwd(), 'src');
+  const coreModuleNames = getCoreModuleNames();
+  const allExcludedModules = [...new Set([...coreModuleNames, ...dynamicModulesToExclude])];
+
+  const directories = fs.readdirSync(srcPath, { withFileTypes: true });
+  // const enabledModules = directories
+  //   .filter(d => d.isDirectory() && !allExcludedModules.includes(d.name))
+  //   .map(d => d.name);
+
+  const enabledModules = directories
+    .filter(dirent => {
+      const isValidDirectory = dirent.isDirectory() && !allExcludedModules.includes(dirent.name);
+
+      if (!isValidDirectory) return false;
+
+      const fullPath = path.join(srcPath, dirent.name);
+      const files = fs.readdirSync(fullPath);
+      // skip if empty directory
+      return files.length > 0;
+    })
+    .map(dirent => dirent.name);
+
+  console.log(`Enabled dynamic modules:`, enabledModules);
+  return enabledModules;
+}
+
+export const getCoreModuleNames = (): string[] => {
+  // return ['iam', 'common', 'queues', 'app-builder'];
+  return ['solid-core'];
+}

package/src/seeders/seed-data/solid-core-metadata.json

@@ -4308,6 +4308,33 @@
             "isSystem": true,
             "isUserKey": true
           },
+          {
+            "name": "displayName",
+            "displayName": "Display Name",
+            "type": "shortText",
+            "ormType": "varchar",
+            "length": 256,
+            "required": false,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true,
+            "isUserKey": false
+          },
+          {
+            "name": "description",
+            "displayName": "Description",
+            "type": "longText",
+            "ormType": "text",
+            "required": false,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true,
+            "description": "This is a description of the dashboard configuration, providing context and details about the dashboard."
+          },
           {
             "name": "layoutJson",
             "displayName": "Layout Json",
@@ -11075,6 +11102,12 @@
               "name": "name"
             }
           },
+          {
+            "type": "field",
+            "attrs": {
+              "name": "displayName"
+            }
+          },
           {
             "type": "field",
             "attrs": {
@@ -11138,6 +11171,18 @@
                                   "name": "name"
                                 }
                               },
+                              {
+                                "type": "field",
+                                "attrs": {
+                                  "name": "displayName"
+                                }
+                              },
+                              {
+                                "type": "field",
+                                "attrs": {
+                                  "name": "description"
+                                }
+                              },
                               {
                                 "type": "field",
                                 "attrs": {

package/src/services/crud.service.ts

@@ -111,7 +111,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
     }
 
     private async validateAndTransformDto(field: FieldMetadata, dto: any, files: Express.Multer.File[], hasMediaFields: boolean, isPartialUpdate: boolean = false, isUpdate: boolean = false) {
-        const fieldManager: FieldCrudManager = this.fieldCrudManager(field, this.entityManager, isPartialUpdate, isUpdate);
+        const fieldManager: FieldCrudManager = await this.fieldCrudManager(field, this.entityManager, isPartialUpdate, isUpdate);
         const validationErrors = fieldManager.validate(dto, files);
         const errors = (validationErrors instanceof Promise) ? await validationErrors : validationErrors;
         if (errors.length > 0) {
@@ -259,7 +259,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         }
     }
 
-    private fieldCrudManager(fieldMetadata: FieldMetadata, entityManager: EntityManager, isPartialUpdate: boolean = false, isUpdate: boolean = false): FieldCrudManager {
+    private async fieldCrudManager(fieldMetadata: FieldMetadata, entityManager: EntityManager, isPartialUpdate: boolean = false, isUpdate: boolean = false) {
         const commonOptions = { required: fieldMetadata.required && !isPartialUpdate, fieldName: fieldMetadata.name, isUpdate };
         switch (fieldMetadata.type) {
             case SolidFieldType.shortText: {
@@ -326,11 +326,13 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
             case SolidFieldType.relation: {
                 // Identify if the field is for the inverse side or not
                 if (fieldMetadata.relationType === RelationType.manyToOne) {
+                    const relationCoModelUserKeyFieldName = await this.getUserKeyFieldNameForModel(fieldMetadata.relationCoModelSingularName);
                     const manyToOneOptions: ManyToOneRelationFieldOptions = {
                         ...commonOptions,
                         relationCoModelSingularName: fieldMetadata.relationCoModelSingularName,
-                        modelUserKeyFieldName: fieldMetadata.model.userKeyField?.name,
+                        // modelUserKeyFieldName: fieldMetadata.model.userKeyField?.name,
                         modelSingularName: fieldMetadata.model.singularName,
+                        relationCoModelUserKeyFieldName: relationCoModelUserKeyFieldName,
                         entityManager,
                     }
                     return new ManyToOneRelationFieldCrudManager(manyToOneOptions);
@@ -677,7 +679,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
 
             // Process each field
             for (const field of model.fields) {
-                const fieldManager: FieldCrudManager = this.fieldCrudManager(field, this.entityManager);
+                const fieldManager: FieldCrudManager = await this.fieldCrudManager(field, this.entityManager);
                 const validationErrors = await fieldManager.validate(createDto, files);
                 if (validationErrors.length > 0) {
                     throw new BadRequestException(`Validation errors in ${field.name} are invalid: ${validationErrors.map(e => e.error).join(', ')}`);
@@ -871,5 +873,13 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
 
         return this.getFieldMetadataRecursively(remainingParts, relationCoModel.fields);
     }
+
+    async getUserKeyFieldNameForModel(modelSingularName: string): Promise<string> {
+        const model = await this.modelMetadataService.findOneBySingularName(modelSingularName, ['userKeyField']);
+        if (!model) {
+            throw new BadRequestException(`Model ${modelSingularName} not found`);
+        }
+        return model.userKeyField?.name || '';
+    }
 }
 

package/src/services/dashboard.service.ts

@@ -129,10 +129,15 @@ export class DashboardService extends CRUDService<Dashboard> {
   }
 
   private async writeToConfig(metaData: any, dashboard: Dashboard, filePath: string) {
-    if (metaData.dashboards) {
+    if (metaData.dashboards && Array.isArray(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;
+      if (dashboardIndex !== -1) {
+        metaData.dashboards[dashboardIndex] = dto;
+      }
+      else {
+        metaData.dashboards.push(dto);
+      }
     }
     else {
       const dashboards = [];

package/src/services/mcp-tool-response-handlers/solid-create-module-mcp-tool-response-handler.service.ts

@@ -36,7 +36,7 @@ export class SolidCreateModuleMcpToolResponseHandler implements IMcpToolResponse
         // This creates the module-metadata.json file....
         const moduleObj = await this.moduleMetadataService.create(createDto);
 
-        const seeder = this.solidRegistry.getSeeders().filter((seeder) => seeder.name === 'ModuleMetadataSeederService').map((seeder) => seeder.instance).pop();
+        // const seeder = this.solidRegistry.getSeeders().filter((seeder) => seeder.name === 'ModuleMetadataSeederService').map((seeder) => seeder.instance).pop();
 
         // Now we need to run solid seed & then solid refresh-model --name <module-name>
         await this.moduleMetadataService.generateCode({ moduleId: moduleObj.id });
@@ -46,7 +46,10 @@ export class SolidCreateModuleMcpToolResponseHandler implements IMcpToolResponse
         // await seeder.seed();
 
         // TODO: decide on some shape to return hre...
-        return {}
+        return {
+            seedingRequired: true,
+            serverRebooting: true,
+        }
     }
 
 }

package/src/services/sql-expression-resolver.service.ts

@@ -1,5 +1,6 @@
 import { Injectable } from "@nestjs/common";
 import { SqlExpression, SqlExpressionOperator } from "./question-data-providers/chartjs-sql-data-provider.service";
+import { RequestContextService } from "./request-context.service";
 
 export interface SqlReplacementResult {
   rawSql: string;
@@ -8,10 +9,25 @@ export interface SqlReplacementResult {
 
 @Injectable()
 export class SqlExpressionResolverService {
+  constructor(private readonly requestContextService: RequestContextService) { }
   resolveSqlWithExpressions(sql: string, expressions: SqlExpression[]): SqlReplacementResult {
     const variableToColumnMap: Record<string, string> = {};
     const variablePattern = /{{\s*(\w+)\s*\[\s*([\w.]+)\s*\]\s*}}/g;
 
+    let paramIndex = 1;
+    const parameters: any[] = [];
+
+    // Handle sql expression tokens like {{$activeUserId}} in the SQL string
+    if (sql.includes('{{$activeUserId}}')) {
+      const activeUser = this.requestContextService.getActiveUser();
+      if (activeUser && activeUser.sub) {
+        // Replace custom placeholder with parameter placeholder ($1)
+        sql = sql.replace(/\{\{\$activeUserId\}\}/g, `$${paramIndex++}`);
+        // Add the active user ID to parameters
+        parameters.push(activeUser.sub);
+      }
+    }
+
     // --- Pass 1: extract variable -> column mappings ---
     let simplifiedSql = sql.replace(variablePattern, (_, variableName, columnName) => {
       variableToColumnMap[variableName] = columnName;
@@ -19,8 +35,6 @@ export class SqlExpressionResolverService {
     });
 
     // --- Pass 2: Replace each variable with positional fragment ---
-    let paramIndex = 1;
-    const parameters: any[] = [];
 
     for (const expr of expressions) {
       const column = variableToColumnMap[expr.variableName];

package/src/subscribers/dashboard.subscriber.ts

@@ -1,11 +1,9 @@
 import { Injectable, Logger } from '@nestjs/common';
 import { InjectDataSource } from "@nestjs/typeorm";
-import * as fs from 'fs/promises'; // Use the Promise-based version of fs for async/await
 import { Dashboard } from 'src/entities/dashboard.entity';
 import { ModuleMetadataHelperService } from "src/helpers/module-metadata-helper.service";
-import { DashboardMapper } from 'src/mappers/dashboard-mapper';
 import { DashboardService } from 'src/services/dashboard.service';
-import { DataSource, EntitySubscriberInterface, InsertEvent, UpdateEvent } from "typeorm";
+import { DataSource, EntityManager, EntitySubscriberInterface, InsertEvent, UpdateEvent } from "typeorm";
 
 @Injectable()
 export class DashboardSubscriber implements EntitySubscriberInterface<Dashboard> {
@@ -28,7 +26,7 @@ export class DashboardSubscriber implements EntitySubscriberInterface<Dashboard>
             this.logger.debug('No dashboard entity found in the DashboardSubscriber afterInsert method');
             return;
         }
-        await this.dashboardService.saveDashboardToConfig(event.entity);
+        await this.saveDashboardToConfig(event.entity, event.queryRunner.manager);
     }
 
     async afterUpdate(event: UpdateEvent<Dashboard>) {
@@ -37,7 +35,28 @@ export class DashboardSubscriber implements EntitySubscriberInterface<Dashboard>
             return;
         }
 
-        await this.dashboardService.saveDashboardToConfig(event.databaseEntity);
+        await this.saveDashboardToConfig(event.databaseEntity, event.queryRunner.manager);
+    }
+
+    private async saveDashboardToConfig(dashboard: Dashboard, entityManager: EntityManager): Promise<void> {
+        if (!dashboard || !dashboard.id) {
+            this.logger.debug('Dashboard or dashboard id is undefined');
+            return;
+        }
+
+        // Load the dashboard with module relation populated
+        const populatedDashboard = await entityManager.findOne(Dashboard, {
+            where: { id: dashboard.id },
+            relations: ['module','dashboardVariables', 'questions', 'questions.questionSqlDatasetConfigs'],
+        });
+
+        if (!populatedDashboard) {
+            this.logger.error(`Dashboard not found for id ${dashboard.id}`);
+            return;
+        }
+
+        // Call the saveDashboardToConfig method from the DashboardService
+        await this.dashboardService.saveDashboardToConfig(populatedDashboard);
     }
 
 }