@solidstarters/solid-core 1.2.138 → 1.2.140

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.138",
+  "version": "1.2.140",
   "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/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/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/mcp-tool-response-handlers/mcp-tool-response-handler-factory.service.ts

@@ -1,10 +1,8 @@
-import { Logger } from '@nestjs/common';
-import { Injectable } from '@nestjs/common';
+import { Injectable, Logger } from '@nestjs/common';
 
-import { QueueMessage, QueuePublisher } from 'src/interfaces/mq';
 import { classify } from '@angular-devkit/core/src/utils/strings';
-import { SolidIntrospectService } from '../solid-introspect.service';
 import { IMcpToolResponseHandler } from 'src/interfaces';
+import { SolidIntrospectService } from '../solid-introspect.service';
 
 
 @Injectable()

package/src/services/mcp-tool-response-handlers/solid-add-field-mcp-tool-response-handler.service.ts

@@ -0,0 +1,56 @@
+import { Injectable } from "@nestjs/common";
+import { UpdateModelMetaDataDto } from "src/dtos/update-model-metadata.dto";
+import { AiInteraction } from "src/entities/ai-interaction.entity";
+import { FieldMetadata } from "src/entities/field-metadata.entity";
+import { SolidRegistry } from "src/helpers/solid-registry";
+import { IMcpToolResponseHandler } from "../../interfaces";
+import { FieldMetadataService } from "../field-metadata.service";
+import { ModelMetadataService } from "../model-metadata.service";
+
+@Injectable()
+// solid_add_field
+export class SolidAddFieldMcpToolResponseHandler implements IMcpToolResponseHandler {
+
+    constructor(
+        private readonly modelMetadataService: ModelMetadataService,
+        private readonly fieldMetadataService: FieldMetadataService,
+        private readonly solidRegistry: SolidRegistry,
+    ) {
+    }
+
+    async apply(aiInteraction: AiInteraction) {
+        // const aiResponse = JSON.parse(aiInteraction.message);
+        const escapedMessage = aiInteraction.message.replace(/\\'/g, "'");
+        const aiResponse = JSON.parse(escapedMessage);
+
+        const { modelUserKey, fieldSchema } = aiResponse;
+
+        // TODO: Validate if another field with same name exists, if it does then raise an error...
+
+        // TODO: load the model with the fields.
+        const modelMetadata = await this.modelMetadataService.findOneByUserKey(modelUserKey, ['fields']);
+        if (!modelMetadata) {
+            throw new Error(`Model with user key ${modelUserKey} not found.`);
+        }
+
+        // Add the fieldSchema to the model fields array
+        fieldSchema['modelId'] = modelMetadata.id;
+        modelMetadata.fields.push(fieldSchema as FieldMetadata);
+
+        const modelObj = await this.modelMetadataService.update(modelMetadata.id, modelMetadata as unknown as UpdateModelMetaDataDto);
+
+
+        // This creates the module-metadata.json file....
+        // const modelObj = await this.fieldMetadataService.create(fieldSchema as CreateFieldMetadataDto);
+
+        // Now we need to run solid seed & then solid refresh-model --name <module-name>
+        await this.modelMetadataService.handleGenerateCode({ modelId: modelMetadata.id });
+
+        // TODO: decide on some shape to return hre...
+        return {
+            seedingRequired: true,
+            serverRebooting: true,
+        }
+    }
+
+}

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

@@ -0,0 +1,39 @@
+import { Injectable } from "@nestjs/common";
+import { plainToInstance } from "class-transformer";
+import { CreateDashboardDto } from "src/dtos/create-dashboard.dto";
+import { AiInteraction } from "src/entities/ai-interaction.entity";
+import { IMcpToolResponseHandler } from "../../interfaces";
+import { DashboardService } from "../dashboard.service";
+
+@Injectable()
+export class SolidCreateDashboardMcpToolResponseHandler implements IMcpToolResponseHandler {
+
+    constructor(
+        private readonly dashboardService: DashboardService,
+    ) {
+    }
+
+    async apply(aiInteraction: AiInteraction) {
+        const escapedMessage = aiInteraction.message.replace(/\\'/g, "'");
+        const aiResponseMessage = JSON.parse(escapedMessage);
+
+        // const aiResponse = JSON.parse(aiInteraction.message);
+
+        //FIXME: Replace \' with ' in the response, since the AI response seems to contain \' which is invalid JSON.
+        // This is a workaround for now, until we find a better solution.
+        // const aiResponseMessageReplaced = aiResponse['message'].replace(/\\'/g, "'");
+
+        const dashboardDto = plainToInstance(CreateDashboardDto, aiResponseMessage);
+        dashboardDto['layoutJson'] = JSON.stringify(dashboardDto['layoutJson']);
+
+
+        const dashboard = await this.dashboardService.create(dashboardDto, []);
+
+        // TODO: decide on some shape to return hre...
+        return {
+            seedingRequired: false,
+            serverRebooting: false,
+        }
+    }
+
+}

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

@@ -0,0 +1,38 @@
+import { Injectable } from "@nestjs/common";
+import { plainToInstance } from "class-transformer";
+import { CreateDashboardQuestionDto } from "src/dtos/create-dashboard-question.dto";
+import { AiInteraction } from "src/entities/ai-interaction.entity";
+import { IMcpToolResponseHandler } from "../../interfaces";
+import { DashboardQuestionService } from "../dashboard-question.service";
+
+@Injectable()
+export class SolidCreateDashboardQuestionMcpToolResponseHandler implements IMcpToolResponseHandler {
+
+    constructor(
+        private readonly dashboardQuestionService: DashboardQuestionService,
+    ) {
+    }
+
+    async apply(aiInteraction: AiInteraction) {
+        const escapedMessage = aiInteraction.message.replace(/\\'/g, "'");
+        const aiResponseMessage = JSON.parse(escapedMessage);
+
+        //FIXME: Replace \' with ' in the response, since the AI response seems to contain \' which is invalid JSON.
+        // This is a workaround for now, until we find a better solution.
+        // const aiResponseMessageReplaced = aiResponseMessage['message'].replace(/\\'/g, "'");
+        // const dashboardUserKey = aiResponseMessageReplaced['dashboardUserKey'];
+        // if (!dashboardUserKey) {
+        //     throw new Error("Dashboard User Key is required to create a Dashboard Question.");
+        // }
+        const dashboardQuestionDto = plainToInstance(CreateDashboardQuestionDto, aiResponseMessage);
+
+        const dashboardQuestion = await this.dashboardQuestionService.create(dashboardQuestionDto, []);
+
+        // TODO: decide on some shape to return hre...
+        return {
+            seedingRequired: false,
+            serverRebooting: false,
+        }
+    }
+
+}

package/src/services/mcp-tool-response-handlers/solid-create-dashboard-question-sql-dataset-config-mcp-tool-response-handler.service.ts

@@ -0,0 +1,40 @@
+import { Injectable } from "@nestjs/common";
+import { plainToInstance } from "class-transformer";
+import { AiInteraction } from "src/entities/ai-interaction.entity";
+import { IMcpToolResponseHandler } from "../../interfaces";
+import { DashboardQuestionSqlDatasetConfigService } from "../dashboard-question-sql-dataset-config.service";
+import { CreateDashboardQuestionSqlDatasetConfigDto } from "src/dtos/create-dashboard-question-sql-dataset-config.dto";
+
+@Injectable()
+export class SolidCreateDashboardQuestionSqlDatasetConfigMcpToolResponseHandler implements IMcpToolResponseHandler {
+
+    constructor(
+        private readonly dashboardQuestionSqlDatasetConfigService: DashboardQuestionSqlDatasetConfigService,
+    ) {
+    }
+
+    async apply(aiInteraction: AiInteraction) {
+        // const aiResponse = JSON.parse(aiInteraction.message);
+        const escapedMessage = aiInteraction.message.replace(/\\'/g, "'");
+        const aiResponseMessage = JSON.parse(escapedMessage);
+
+        // FIXME: Replace \' with ' in the response, since the AI response seems to contain \' which is invalid JSON.
+        // This is a workaround for now, until we find a better solution.
+        // const aiResponseMessageReplaced = aiResponse['message'].replace(/\\'/g, "'");
+        // const dashboardUserKey = aiResponseMessageReplaced['dashboardUserKey'];
+        // if (!dashboardUserKey) {
+        //     throw new Error("Dashboard User Key is required to create a Dashboard Question.");
+        // }
+        const dto = plainToInstance(CreateDashboardQuestionSqlDatasetConfigDto, aiResponseMessage);
+        dto['options'] = JSON.stringify(dto['options']);
+
+        const dashboardQuestion = await this.dashboardQuestionSqlDatasetConfigService.create(dto, []);
+
+        // TODO: decide on some shape to return hre...
+        return {
+            seedingRequired: false,
+            serverRebooting: false,
+        }
+    }
+
+}

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

@@ -0,0 +1,39 @@
+import { Injectable } from "@nestjs/common";
+import { plainToInstance } from "class-transformer";
+import { CreateDashboardQuestionDto } from "src/dtos/create-dashboard-question.dto";
+import { AiInteraction } from "src/entities/ai-interaction.entity";
+import { IMcpToolResponseHandler } from "../../interfaces";
+import { DashboardQuestionService } from "../dashboard-question.service";
+
+@Injectable()
+export class SolidCreateDashboardWidgetMcpToolResponseHandler implements IMcpToolResponseHandler {
+
+    constructor(
+        private readonly dashboardQuestionService: DashboardQuestionService,
+    ) {
+    }
+
+    async apply(aiInteraction: AiInteraction) {
+        const escapedMessage = aiInteraction.message.replace(/\\'/g, "'");
+        const aiResponseMessage = JSON.parse(escapedMessage);
+
+        //FIXME: Replace \' with ' in the response, since the AI response seems to contain \' which is invalid JSON.
+        // This is a workaround for now, until we find a better solution.
+        // const aiResponseMessageReplaced = aiResponseMessage['message'].replace(/\\'/g, "'");
+        // const dashboardUserKey = aiResponseMessageReplaced['dashboardUserKey'];
+        // if (!dashboardUserKey) {
+        //     throw new Error("Dashboard User Key is required to create a Dashboard Question.");
+        // }
+        const dashboardQuestionDto = plainToInstance(CreateDashboardQuestionDto, aiResponseMessage);
+        dashboardQuestionDto['questionSqlDatasetConfigsCommand'] = "update";
+
+        const dashboardQuestion = await this.dashboardQuestionService.create(dashboardQuestionDto, []);
+
+        // TODO: decide on some shape to return hre...
+        return {
+            seedingRequired: false,
+            serverRebooting: false,
+        }
+    }
+
+}

package/src/services/mcp-tool-response-handlers/solid-create-model-with-fields-mcp-tool-response-handler.service.ts

@@ -0,0 +1,46 @@
+import { Injectable } from "@nestjs/common";
+import { IMcpToolResponseHandler } from "../../interfaces";
+import { AiInteraction } from "src/entities/ai-interaction.entity";
+import { SolidRegistry } from "src/helpers/solid-registry";
+import { ModelMetadataService } from "../model-metadata.service";
+import { CreateModelMetadataDto } from "src/dtos/create-model-metadata.dto";
+import { ModuleMetadataService } from "../module-metadata.service";
+
+@Injectable()
+export class SolidCreateModelWithFieldsMcpToolResponseHandler implements IMcpToolResponseHandler {
+
+    constructor(
+        private readonly moduleMetadataService: ModuleMetadataService,
+        private readonly modelMetadataService: ModelMetadataService,
+        private readonly solidRegistry: SolidRegistry,
+    ) {
+    }
+
+    async apply(aiInteraction: AiInteraction) {
+        // const aiResponse = JSON.parse(aiInteraction.message);
+        const escapedMessage = aiInteraction.message.replace(/\\'/g, "'");
+        const aiResponse = JSON.parse(escapedMessage);
+
+        const { moduleUserKey, modelSchema } = aiResponse;
+        const moduleMetadata = await this.moduleMetadataService.findOneByUserKey(moduleUserKey);
+        if (!moduleMetadata) {
+            throw new Error(`Module with user key ${moduleUserKey} not found.`);
+        }
+        modelSchema['moduleId'] = moduleMetadata.id;
+
+        // TODO: Validate if another model with same name exists, if it does then raise an error...
+
+        // This creates the module-metadata.json file....
+        const modelObj = await this.modelMetadataService.create(modelSchema as CreateModelMetadataDto);
+
+        // Now we need to run solid seed & then solid refresh-model --name <module-name>
+        await this.modelMetadataService.handleGenerateCode({ modelId: modelObj.id });
+
+        // TODO: decide on some shape to return hre...
+        return {
+            seedingRequired: true,
+            serverRebooting: true,
+        }
+    }
+
+}

package/src/solid-core.module.ts

@@ -203,6 +203,7 @@ import { ChatterMessageDetailsService } from './services/chatter-message-details
 import { ChatterMessageService } from './services/chatter-message.service';
 import { ConcatComputedFieldProvider } from './services/computed-fields/concat-computed-field-provider.service';
 import { ConcatEntityComputedFieldProvider } from './services/computed-fields/entity/concat-entity-computed-field-provider.service';
+import { CRUDService } from './services/crud.service';
 import { CsvService } from './services/csv.service';
 import { DashboardQuestionSqlDatasetConfigService } from './services/dashboard-question-sql-dataset-config.service';
 import { DashboardQuestionService } from './services/dashboard-question.service';
@@ -216,6 +217,11 @@ import { ExportTransactionService } from './services/export-transaction.service'
 import { ImportTransactionErrorLogService } from './services/import-transaction-error-log.service';
 import { ImportTransactionService } from './services/import-transaction.service';
 import { LocaleService } from './services/locale.service';
+import { McpToolResponseHandlerFactory } from './services/mcp-tool-response-handlers/mcp-tool-response-handler-factory.service';
+import { SolidCreateDashboardMcpToolResponseHandler } from './services/mcp-tool-response-handlers/solid-create-dashboard-mcp-tool-response-handler.service';
+import { SolidCreateDashboardQuestionMcpToolResponseHandler } from './services/mcp-tool-response-handlers/solid-create-dashboard-question-mcp-tool-response-handler.service';
+import { SolidCreateDashboardQuestionSqlDatasetConfigMcpToolResponseHandler } from './services/mcp-tool-response-handlers/solid-create-dashboard-question-sql-dataset-config-mcp-tool-response-handler.service';
+import { SolidCreateModuleMcpToolResponseHandler } from './services/mcp-tool-response-handlers/solid-create-module-mcp-tool-response-handler.service';
 import { FileS3StorageProvider } from './services/mediaStorageProviders/file-s3-storage-provider';
 import { FileStorageProvider } from './services/mediaStorageProviders/file-storage-provider';
 import { ChartJsSqlDataProvider } from './services/question-data-providers/chartjs-sql-data-provider.service';
@@ -246,9 +252,9 @@ import { DashboardVariableSubscriber } from './subscribers/dashboard-variable.su
 import { DashboardSubscriber } from './subscribers/dashboard.subscriber';
 import { SecurityRuleSubscriber } from './subscribers/security-rule.subscriber';
 import { ViewMetadataSubsciber } from './subscribers/view-metadata.subscriber';
-import { CRUDService } from './services/crud.service';
-import { McpToolResponseHandlerFactory } from './services/mcp-tool-response-handlers/mcp-tool-response-handler-factory.service';
-import { SolidCreateModuleMcpToolResponseHandler } from './services/mcp-tool-response-handlers/solid-create-module-mcp-tool-response-handler.service';
+import { SolidCreateDashboardWidgetMcpToolResponseHandler } from './services/mcp-tool-response-handlers/solid-create-dashboard-widget-mcp-tool-response-handler.service';
+import { SolidCreateModelWithFieldsMcpToolResponseHandler } from './services/mcp-tool-response-handlers/solid-create-model-with-fields-mcp-tool-response-handler.service';
+import { SolidAddFieldMcpToolResponseHandler } from './services/mcp-tool-response-handlers/solid-add-field-mcp-tool-response-handler.service';
 
 
 @Global()
@@ -419,7 +425,7 @@ import { SolidCreateModuleMcpToolResponseHandler } from './services/mcp-tool-res
     SmsTemplateService,
     EmailTemplateService,
     PublisherFactory,
-    
+
     McpToolResponseHandlerFactory,
     SolidCreateModuleMcpToolResponseHandler,
 
@@ -528,6 +534,12 @@ import { SolidCreateModuleMcpToolResponseHandler } from './services/mcp-tool-res
     DashboardVariableSubscriber,
     DashboardQuestionSubscriber,
     DashboardQuestionSqlDatasetConfigSubscriber,
+    SolidCreateDashboardMcpToolResponseHandler,
+    SolidCreateDashboardQuestionMcpToolResponseHandler,
+    SolidCreateDashboardQuestionSqlDatasetConfigMcpToolResponseHandler,
+    SolidCreateDashboardWidgetMcpToolResponseHandler,
+    SolidCreateModelWithFieldsMcpToolResponseHandler,
+    SolidAddFieldMcpToolResponseHandler,
   ],
   exports: [
     ModuleMetadataService,

package/src/subscribers/dashboard.subscriber.ts

@@ -1,9 +1,7 @@
 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, EntityManager, EntitySubscriberInterface, InsertEvent, UpdateEvent } from "typeorm";
 
@@ -49,7 +47,7 @@ export class DashboardSubscriber implements EntitySubscriberInterface<Dashboard>
         // Load the dashboard with module relation populated
         const populatedDashboard = await entityManager.findOne(Dashboard, {
             where: { id: dashboard.id },
-            relations: ['module'],
+            relations: ['module','dashboardVariables', 'questions', 'questions.questionSqlDatasetConfigs'],
         });
 
         if (!populatedDashboard) {