@solidstarters/solid-core 1.2.139 → 1.2.141

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.139",
+  "version": "1.2.141",
   "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/repository/view-metadata.repository.ts

@@ -0,0 +1,31 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { Dashboard } from "src/entities/dashboard.entity";
+import { ViewMetadata } from "src/entities/view-metadata.entity";
+import { DataSource, Repository, View } from "typeorm";
+
+@Injectable()
+export class ViewMetadataRepository extends Repository<ViewMetadata> {
+    private readonly logger = new Logger(this.constructor.name);
+
+    constructor(
+        private dataSource: DataSource,
+    ) {
+        super(ViewMetadata, dataSource.createEntityManager());
+    }
+
+    // Custom repository methods can be added here if needed
+    async findByNameAndModelNameAndModuleName(name: string, modelUserKey: string, moduleUserKey: string): Promise<ViewMetadata | null> {
+        const viewMetadata = await this.findOne({
+            where: {
+                name,
+                model: {
+                    singularName: modelUserKey,
+                    module: {
+                        name: moduleUserKey
+                    }
+                }
+            }
+        });
+        return viewMetadata;
+    }
+}

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

@@ -189,7 +189,7 @@ export class ModuleMetadataSeederService {
             // Email templates 
             this.logger.debug(`[Start] Processing email templates for ${moduleMetadata.name}`);
             const emailTemplates: CreateEmailTemplateDto[] = overallMetadata.emailTemplates;
-            await this.seedEmailTemplates(emailTemplates);
+            await this.seedEmailTemplates(emailTemplates, moduleMetadata);
             this.logger.debug(`[End] Processing email templates for ${moduleMetadata.name}`);
 
             // Sms templates
@@ -255,10 +255,11 @@ export class ModuleMetadataSeederService {
             'SavedFiltersController.partialUpdate',
             'SavedFiltersController.update',
             'SavedFiltersController.insertMany',
-            'SavedFiltersController.create'
+            'SavedFiltersController.create',
+            'AuthenticationController.logout'
         ]
         await this.roleService.addPermissionToRole('Internal User', internalRolePermission);
-        await this.roleService.addPermissionToRole('Public', ['SettingController.wrapSettings']);
+        await this.roleService.addPermissionToRole('Public', ['SettingController.wrapSettings','AuthenticationController.logout']);
         this.logger.log(`All Seeders finished`);
         this.logger.log(`Newly created username is: ${usersDetail?.length > 0 ? usersDetail[0]?.username : ''} and password is ${usersDetail?.length > 0 ? usersDetail[0]?.password : ''}`);
     }
@@ -313,7 +314,7 @@ export class ModuleMetadataSeederService {
         }
     }
 
-    async seedEmailTemplates(emailTemplates: CreateEmailTemplateDto[]) {
+    async seedEmailTemplates(emailTemplates: CreateEmailTemplateDto[], moduleMetadata: CreateModuleMetadataDto) {
         if (!emailTemplates) {
             return;
         }
@@ -323,19 +324,24 @@ export class ModuleMetadataSeederService {
             this.logger.log(`Found ${emailTemplate.name} email template`);
 
             // We need to load the actual template contents. 
-            // const emailTemplateFilePath = path.join(process.cwd(), emailTemplate.body);
-
-            // emailTemplate.body = fs.readFileSync(emailTemplateFilePath, 'utf-8').toString()
-            const modulePath = path.dirname(require.resolve('@solidstarters/solid-core'));
-
-            // Resolve the `src` folder
-            const seedDataPath = path.join(modulePath, '../src/seeders/seed-data/email-templates');
-
-            // Example usage
-            const filePath = path.join(seedDataPath, emailTemplate.body);
-
-
-            emailTemplate.body = fs.readFileSync(filePath, 'utf-8').toString();
+            if (moduleMetadata.name === 'solid-core') {
+                const modulePath = path.dirname(require.resolve('@solidstarters/solid-core'));
+                const seedDataPath = path.join(modulePath, '../src/seeders/seed-data/email-templates');
+                const filePath = path.join(seedDataPath, emailTemplate.body);
+                this.logger.log(`Seeding email template from solid-core at path: ${filePath}`);
+                if (fs.existsSync(filePath)) {
+                    emailTemplate.body = fs.readFileSync(filePath, 'utf-8').toString();
+                }
+            }
+            else {
+                // Check if file exists
+                const emailTemplateHandlebar = `module-metadata/${moduleMetadata.name}/email-templates/${emailTemplate.body}`
+                const fullPath = path.join(process.cwd(), emailTemplateHandlebar);
+                this.logger.log(`Seeding custom email template from consuming model at path: ${fullPath}`);
+                if (fs.existsSync(fullPath)) {
+                    emailTemplate.body = fs.readFileSync(fullPath, 'utf-8').toString();
+                }
+            }
 
             // Save to DB.
             await this.emailTemplateService.removeByName(emailTemplate.name);

package/src/services/computed-fields/entity/alpha-num-external-id-computed-field-provider.ts

@@ -0,0 +1,70 @@
+import { Injectable } from '@nestjs/common';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { ComputedFieldProvider } from 'src/decorators/computed-field-provider.decorator';
+import { ComputedFieldMetadata } from 'src/helpers/solid-registry';
+import { IEntityPreComputeFieldProvider } from 'src/interfaces';
+// import {
+//   ComputedFieldMetadata,
+//   ComputedFieldProvider,
+//   IEntityPreComputeFieldProvider,
+// } from '@solidstarters/solid-core';
+import { EntityManager } from 'typeorm';
+// import { Agreement } from '../entities/agreement.entity';
+
+@ComputedFieldProvider()
+@Injectable()
+export class AgreementIdComputationProvider implements IEntityPreComputeFieldProvider<any, any, string> {
+  constructor(
+    @InjectEntityManager()
+    private readonly entityManager: EntityManager
+  ) { }
+
+  generateRandomCode(length = 5): string {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+      result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+  }
+
+  async isAgreementIdUnique(agreementId: string): Promise<boolean> {
+    // const count = await this.entityManager.count(Agreement, {
+    //   where: { agreementId },
+    // });
+    // return count === 0;
+    return false;
+  }
+
+  async generateUniqueAgreementId(codeLength: number): Promise<string> {
+    const maxAttempts = 10;
+
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const newId = this.generateRandomCode(codeLength);
+
+      const isUnique = await this.isAgreementIdUnique(newId);
+
+      if (isUnique) {
+        return newId;
+      }
+    }
+
+    throw new Error('Failed to generate a unique agreement ID after multiple attempts');
+  }
+
+  async preComputeValue(triggerEntity: any, computedFieldMetadata: ComputedFieldMetadata<any>): Promise<string> {
+    const prefix = computedFieldMetadata.computedFieldValueProviderCtxt['prefix'];
+    const codeLength = computedFieldMetadata.computedFieldValueProviderCtxt['length'] || 5;
+    const uniqueCode = await this.generateUniqueAgreementId(codeLength);
+    return `${prefix}-${uniqueCode}`;
+  }
+
+  name(): string {
+    return 'AgreementIdComputationProvider';
+  }
+
+  help(): string {
+    return 'Provider used to compute values for the agreement id field on save.';
+  }
+
+}

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,113 @@
+import { Injectable } from "@nestjs/common";
+import { plainToInstance } from "class-transformer";
+import { CreateDashboardDto } from "src/dtos/create-dashboard.dto";
+import { UpdateMenuItemMetadataDto } from "src/dtos/update-menu-item-metadata.dto";
+import { AiInteraction } from "src/entities/ai-interaction.entity";
+import { Dashboard } from "src/entities/dashboard.entity";
+import { IMcpToolResponseHandler } from "../../interfaces";
+import { ActionMetadataService } from "../action-metadata.service";
+import { DashboardService } from "../dashboard.service";
+import { MenuItemMetadataService } from "../menu-item-metadata.service";
+import { ModelMetadataService } from "../model-metadata.service";
+import { ModuleMetadataService } from "../module-metadata.service";
+import { RoleMetadataService } from "../role-metadata.service";
+
+@Injectable()
+export class SolidCreateDashboardMcpToolResponseHandler implements IMcpToolResponseHandler {
+
+    constructor(
+        private readonly dashboardService: DashboardService,
+        private readonly actionMetadataService: ActionMetadataService,
+        private readonly menuItemMetadataService: MenuItemMetadataService,
+        private readonly moduleMetadataService: ModuleMetadataService,
+        private readonly modelMetadataService: ModelMetadataService,
+        private readonly roleService: RoleMetadataService, // Assuming roleService is a Mongoose model, adjust as necessary
+    ) {
+    }
+
+    async apply(aiInteraction: AiInteraction) {
+        const escapedMessage = aiInteraction.message.replace(/\\'/g, "'");
+        const aiResponseMessage = JSON.parse(escapedMessage);
+
+        const { dashboardDto, dashboard } = await this.createDashboard(aiResponseMessage);
+
+        const { moduleUserKey, actionMetadataEntity } = await this.createActionMetadataEntry(dashboardDto, dashboard);
+
+        await this.createMenuItemEntry(dashboard, moduleUserKey, actionMetadataEntity);
+
+        // TODO: decide on some shape to return hre...
+        return {
+            seedingRequired: false,
+            serverRebooting: false,
+        }
+    }
+
+
+    private async createMenuItemEntry(dashboard: Dashboard, moduleUserKey: string, actionMetadataEntity: any) {
+        const menuData = {
+            displayName: dashboard.displayName || dashboard.name,
+            name: `${moduleUserKey}-${dashboard.name}-dashboard-menu-item`,
+            sequenceNumber: 1,
+            actionUserKey: actionMetadataEntity.name,
+            moduleUserKey: moduleUserKey,
+            parentMenuItemUserKey: '',
+        };
+
+        const adminRole = await this.roleService.findRoleByName('Admin');
+        const specifiedRoles = menuData['roles'];
+
+        // If the developer has specified roles, then resolve them, making sure that admin role is also given.
+        const specifiedRoleObjects = [adminRole];
+        if (specifiedRoles) {
+            for (let i = 0; i < specifiedRoles.length; i++) {
+                const specifiedRole = specifiedRoles[i];
+                const specifiedRoleObject = await this.roleService.findRoleByName(specifiedRole);
+                if (!specifiedRoleObject) {
+                    throw new Error(`Invalid role: (${specifiedRole}) specified against menu with display name ${menuData.displayName}.`);
+                }
+                specifiedRoleObjects.push(specifiedRoleObject);
+            }
+        }
+
+        menuData['roles'] = specifiedRoleObjects;
+        menuData['action'] = await this.actionMetadataService.findOneByUserKey(menuData.actionUserKey);
+        menuData['module'] = await this.moduleMetadataService.findOneByUserKey(menuData.moduleUserKey);
+
+        if (menuData.parentMenuItemUserKey) {
+            menuData['parentMenuItem'] = await this.menuItemMetadataService.findOneByUserKey(menuData.parentMenuItemUserKey);
+        } else {
+            menuData['parentMenuItem'] = null;
+        }
+        await this.menuItemMetadataService.upsert(menuData as unknown as UpdateMenuItemMetadataDto);
+    }
+
+    private async createActionMetadataEntry(dashboardDto: CreateDashboardDto, dashboard: Dashboard) {
+        const moduleUserKey = dashboardDto.moduleUserKey;
+        const actionMetadata = {
+            name: `${dashboard.name}-view`,
+            displayName: dashboard.displayName || dashboard.name,
+            type: 'custom',
+            domain: "{}",
+            context: "{}",
+            customComponent: `/admin/core/${moduleUserKey}/dashboards?dashboardName=${dashboard.name}`,
+            customIsModal: true,
+            serverEndpoint: '',
+            moduleUserKey: moduleUserKey,
+            modelUserKey: '',
+            viewUserKey: `${dashboard.name}-view`,
+        };
+        actionMetadata['module'] = await this.moduleMetadataService.findOneByUserKey(actionMetadata.moduleUserKey);
+        if (actionMetadata.modelUserKey) {
+            actionMetadata['model'] = await this.modelMetadataService.findOneByUserKey(actionMetadata.modelUserKey);
+        }
+        const actionMetadataEntity = await this.actionMetadataService.upsert(actionMetadata);
+        return { moduleUserKey, actionMetadataEntity };
+    }
+
+    private async createDashboard(aiResponseMessage: any) {
+        const dashboardDto = plainToInstance(CreateDashboardDto, aiResponseMessage);
+        dashboardDto['layoutJson'] = JSON.stringify(dashboardDto['layoutJson']);
+        const dashboard = await this.dashboardService.create(dashboardDto, []);
+        return { dashboardDto, dashboard };
+    }
+}

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/services/mcp-tool-response-handlers/solid-save-model-layout-mcp-tool-response-handler.service.ts

@@ -0,0 +1,34 @@
+import { Injectable } from "@nestjs/common";
+import { AiInteraction } from "src/entities/ai-interaction.entity";
+import { ViewMetadataRepository } from "src/repository/view-metadata.repository";
+import { IMcpToolResponseHandler } from "../../interfaces";
+
+@Injectable()
+export class SolidCreateModelLayoutMcpToolResponseHandler implements IMcpToolResponseHandler {
+
+    constructor(
+        private readonly viewMetadataRepository: ViewMetadataRepository,
+    ) {
+    }
+
+    async apply(aiInteraction: AiInteraction) {
+        const aiResponse = JSON.parse(aiInteraction.message);
+
+        // Get the data for resolving the view metadata
+        const {name, modelUserKey, moduleUserKey, layout} = aiResponse;
+
+        // Fetch the view metadata for the given model and module and the view name
+        const viewMetadata = await this.viewMetadataRepository.findByNameAndModelNameAndModuleName(name, modelUserKey, moduleUserKey);
+
+        viewMetadata.layout = JSON.stringify(layout);
+        // Save the updated view metadata
+        await this.viewMetadataRepository.save(viewMetadata);
+
+        // TODO: decide on some shape to return hre...
+        return {
+            seedingRequired: false,
+            serverRebooting: false,
+        }
+    }
+
+}

package/src/services/view-metadata.service.ts

@@ -20,6 +20,7 @@ import { ViewMetadata } from '../entities/view-metadata.entity';
 import { ActionMetadataService } from './action-metadata.service';
 import { SolidIntrospectService } from './solid-introspect.service';
 import { UserViewMetadataService } from './user-view-metadata.service';
+import { ViewMetadataRepository } from 'src/repository/view-metadata.repository';
 
 @Injectable()
 export class ViewMetadataService extends CRUDService<ViewMetadata> {
@@ -35,8 +36,8 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
     readonly userViewMetadataService: UserViewMetadataService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
-    @InjectRepository(ViewMetadata, 'default')
-    readonly repo: Repository<ViewMetadata>,
+    // @InjectRepository(ViewMetadata, 'default')
+    readonly repo: ViewMetadataRepository,
     @InjectRepository(FieldMetadata)
     private readonly fieldMetadataRepo: Repository<FieldMetadata>,
     @InjectRepository(ModelMetadata)

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,11 @@ 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';
+import { ViewMetadataRepository } from './repository/view-metadata.repository';
+import { SolidCreateModelLayoutMcpToolResponseHandler } from './services/mcp-tool-response-handlers/solid-save-model-layout-mcp-tool-response-handler.service';
 
 
 @Global()
@@ -419,7 +427,7 @@ import { SolidCreateModuleMcpToolResponseHandler } from './services/mcp-tool-res
     SmsTemplateService,
     EmailTemplateService,
     PublisherFactory,
-    
+
     McpToolResponseHandlerFactory,
     SolidCreateModuleMcpToolResponseHandler,
 
@@ -528,6 +536,14 @@ import { SolidCreateModuleMcpToolResponseHandler } from './services/mcp-tool-res
     DashboardVariableSubscriber,
     DashboardQuestionSubscriber,
     DashboardQuestionSqlDatasetConfigSubscriber,
+    SolidCreateDashboardMcpToolResponseHandler,
+    SolidCreateDashboardQuestionMcpToolResponseHandler,
+    SolidCreateDashboardQuestionSqlDatasetConfigMcpToolResponseHandler,
+    SolidCreateDashboardWidgetMcpToolResponseHandler,
+    SolidCreateModelWithFieldsMcpToolResponseHandler,
+    SolidAddFieldMcpToolResponseHandler,
+    ViewMetadataRepository,
+    SolidCreateModelLayoutMcpToolResponseHandler,
   ],
   exports: [
     ModuleMetadataService,