@solidstarters/solid-core 1.2.183 → 1.2.185

package/src/services/genai/mcp-handlers/solid-add-custom-service-method-mcp-handler.service.ts

@@ -0,0 +1,69 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { AiInteraction } from "src/entities/ai-interaction.entity";
+import { IMcpToolResponseHandler, McpComputedProviderResponse, PlanStep } from "../../../interfaces";
+import { SolidTsMorphService } from "src/services/solid-ts-morph.service";
+
+const RESTART_TOUCH_FILE = process.env.MCP_RESTART_TOUCH_FILE || "tmp/restart.touch";
+
+@Injectable()
+export class SolidAddCustomServiceMethodMcpHandler implements IMcpToolResponseHandler {
+  private readonly logger = new Logger(SolidAddCustomServiceMethodMcpHandler.name);
+
+  constructor(private readonly tsMorph: SolidTsMorphService) { }
+
+  async apply(aiInteraction: AiInteraction) {
+    const raw = this.safeParse(aiInteraction.message);
+    const payload: McpComputedProviderResponse | undefined = (raw?.data?.plan ? raw.data : raw) as McpComputedProviderResponse;
+
+    if (!payload || !Array.isArray(payload.plan)) {
+      throw new Error("SolidAddCustomServiceMethodMcpHandler: invalid MCP response; missing plan[]");
+    }
+
+    // Batch all plan steps in a single txn so nodemon restarts only once.
+    this.tsMorph.begin();
+    try {
+      for (const step of payload.plan as PlanStep[]) {
+        switch (step.type) {
+          case "createNewFile": {
+            const overwrite = step.overwrite ?? false;
+            this.tsMorph.createNewFile(step.path, step.content, overwrite);
+            break;
+          }
+          case "addMethodToExistingClass": {
+            this.tsMorph.addMethodToExistingClass(
+              step.path,
+              step.className,
+              step.methodName,
+              step.content,
+            );
+            break;
+          }
+          default:
+            throw new Error(`Unsupported plan step type: ${(step as any).type}`);
+        }
+      }
+
+      const result = await this.tsMorph.commit();
+
+      return {
+        seedingRequired: false,
+        serverRebooting: true,
+        appliedSteps: payload.plan.length,
+        wroteFiles: result.wrote,
+      };
+    } catch (err) {
+      this.logger.error(`Apply failed; rolling back. ${String(err)}`);
+      this.tsMorph.rollback();
+      throw err;
+    }
+  }
+
+  private safeParse(str: string): any {
+    try {
+      return JSON.parse(str);
+    } catch {
+      const unescaped = str.replace(/\\'/g, "'");
+      return JSON.parse(unescaped);
+    }
+  }
+}

package/src/services/genai/mcp-handlers/solid-add-question-to-dashboard-mcp-handler.service.ts

@@ -0,0 +1,43 @@
+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 SolidAddQuestionToDashboardMcpHandler implements IMcpToolResponseHandler {
+
+    constructor(
+        private readonly dashboardQuestionService: DashboardQuestionService,
+    ) {
+    }
+
+    async apply(aiInteraction: AiInteraction) {
+        const escapedMessage = aiInteraction.message.replace(/\\'/g, "'");
+        const aiResponseMessage = JSON.parse(escapedMessage);
+
+        const {data} = aiResponseMessage;
+        const { dashboardUserKey, schema} = data;
+
+        //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, schema);
+        dashboardQuestionDto['questionSqlDatasetConfigsCommand'] = "update";
+        dashboardQuestionDto['dashboardUserKey'] = dashboardUserKey;
+
+        const dashboardQuestion = await this.dashboardQuestionService.create(dashboardQuestionDto, []);
+
+        // TODO: decide on some shape to return hre...
+        return {
+            seedingRequired: false,
+            serverRebooting: false,
+        }
+    }
+
+}

package/src/services/genai/mcp-handlers/solid-add-variable-to-dashboard-mcp-handler.service.ts

@@ -0,0 +1,44 @@
+import { Injectable } from "@nestjs/common";
+import { plainToInstance } from "class-transformer";
+import { CreateDashboardVariableDto } from "src/dtos/create-dashboard-variable.dto";
+import { AiInteraction } from "src/entities/ai-interaction.entity";
+import { DashboardVariableService } from "src/services/dashboard-variable.service";
+import { IMcpToolResponseHandler } from "../../../interfaces";
+
+@Injectable()
+export class SolidAddVariableToDashboardMcpHandler implements IMcpToolResponseHandler {
+
+    constructor(
+        private readonly dashboardVariableService: DashboardVariableService,
+    ) {
+    }
+
+    async apply(aiInteraction: AiInteraction) {
+        const escapedMessage = aiInteraction.message.replace(/\\'/g, "'");
+        const aiResponseMessage = JSON.parse(escapedMessage);
+
+        const {data} = aiResponseMessage;
+        const { dashboardUserKey, schema} = data;
+
+        //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 dashboardVariableDto = plainToInstance(CreateDashboardVariableDto, schema);
+        dashboardVariableDto['selectionStaticValues'] = JSON.stringify(dashboardVariableDto['selectionStaticValues'] || []);
+        dashboardVariableDto['defaultValue'] = JSON.stringify(dashboardVariableDto['defaultValue'] || []);
+        dashboardVariableDto['dashboardUserKey'] = dashboardUserKey;
+
+        const dashboardVariable = await this.dashboardVariableService.create(dashboardVariableDto, []);
+
+        // TODO: decide on some shape to return hre...
+        return {
+            seedingRequired: false,
+            serverRebooting: false,
+        }
+    }
+
+}

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

@@ -13,7 +13,7 @@ import { ModuleMetadataService } from "../../module-metadata.service";
 import { RoleMetadataService } from "../../role-metadata.service";
 
 @Injectable()
-export class SolidCreateDashboardMcpHandler implements IMcpToolResponseHandler {
+export class SolidCreateDashboardWithWidgetsMcpHandler implements IMcpToolResponseHandler {
 
     constructor(
         private readonly dashboardService: DashboardService,
@@ -28,8 +28,9 @@ export class SolidCreateDashboardMcpHandler implements IMcpToolResponseHandler {
     async apply(aiInteraction: AiInteraction) {
         const escapedMessage = aiInteraction.message.replace(/\\'/g, "'");
         const aiResponseMessage = JSON.parse(escapedMessage);
-
-        const { dashboardDto, dashboard } = await this.createDashboard(aiResponseMessage);
+        const { data } = aiResponseMessage;
+        const { schema } = data;
+        const { dashboardDto, dashboard } = await this.createDashboard(schema);
 
         const { moduleUserKey, actionMetadataEntity } = await this.createActionMetadataEntry(dashboardDto, dashboard);
 

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

@@ -901,12 +901,12 @@ export class ModelMetadataService {
                 children: [
                   {
                     type: "column",
-                    attrs: { name: "group-1", label: "", className: "col-6" },
+                    attrs: { name: "group-1", label: "", className: "col-12 sm:col-12 md:col-6 lg:col-6" },
                     children: column1Fields
                   },
                   {
                     type: "column",
-                    attrs: { name: "group-2", label: "", className: "col-6" },
+                    attrs: { name: "group-2", label: "", className: "col-12 sm:col-12 md:col-6 lg:col-6" },
                     children: column2Fields
                   }
                 ]
@@ -1014,12 +1014,12 @@ export class ModelMetadataService {
                   children: [
                     {
                       type: "column",
-                      attrs: { name: "group-1", label: "", className: "col-6" },
+                      attrs: { name: "group-1", label: "", className: "col-12 sm:col-12 md:col-6 lg:col-6" },
                       children: firstHalf
                     },
                     {
                       type: "column",
-                      attrs: { name: "group-2", label: "", className: "col-6" },
+                      attrs: { name: "group-2", label: "", className: "col-12 sm:col-12 md:col-6 lg:col-6" },
                       children: secondHalf
                     }
                   ]

package/src/services/setting.service.ts

@@ -76,7 +76,8 @@ export class SettingService extends CRUDService<Setting> {
       solidXGenAiCodeBuilderConfig: JSON.stringify({
             defaultProvider: "",
             availableProviders: []
-        })
+        }),
+      showNameFieldsForRegistration:this.iamConfiguration.showNameFieldsForRegistration
     };
 
     const existingSettings = await this.repo.find();
@@ -187,7 +188,8 @@ export class SettingService extends CRUDService<Setting> {
             defaultProvider: "",
             availableProviders: []
         }),
-      iamAutoGeneratedPassword:this.iamConfiguration.iamAutoGeneratedPassword
+      iamAutoGeneratedPassword:this.iamConfiguration.iamAutoGeneratedPassword,
+      showNameFieldsForRegistration:this.iamConfiguration.showNameFieldsForRegistration
     };
   }
 

package/src/services/solid-ts-morph.service.ts

@@ -3,6 +3,7 @@ import { Injectable, Logger } from "@nestjs/common";
 import { join, dirname, normalize, isAbsolute, basename } from "node:path";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { Project, Node, ObjectLiteralExpression, ArrayLiteralExpression, QuoteKind, IndentationText } from "ts-morph";
+import { MethodDeclarationStructure, StructureKind } from "ts-morph";
 
 type Bucket = "providers" | "exports";
 
@@ -260,4 +261,40 @@ export class SolidTsMorphService {
         this.logger.log(`Staged provider registration in: ${this.rel(abs)} (${registerIn.join(", ")})`);
         return { staged: true };
     }
+
+
+    addMethodToExistingClass(
+        filePath: string,
+        className: string,
+        methodName: string,
+        methodCode: string,
+    ): { staged: boolean; overwritten: boolean; skipped: boolean } {
+        const abs = this.resolveRepoPath(filePath);
+        if (!existsSync(abs))
+            throw new Error(`addMethodToExistingClass: File not found at ${filePath}`);
+
+        const existing = this.project.getSourceFile(abs);
+        const sourceFile = existing
+            ? existing
+            : this.project.createSourceFile(abs, readFileSync(abs, "utf8"), { overwrite: true });
+
+        const targetClass = sourceFile.getClass(className);
+        if (!targetClass)
+            throw new Error(`addMethodToExistingClass: Class ${className} not found in ${filePath}`);
+
+        const existingMethod = targetClass.getMethod(methodName);
+        if (existingMethod) {
+
+            this.logger.log(`Skipped adding method '${methodName}' (already exists)`);
+            return { staged: false, overwritten: false, skipped: true };
+        }
+        // Add the LLM-generated method directly
+        targetClass.addMember(methodCode);
+
+
+        this.dirtySourceFiles.add(abs);
+        this.logger.log(`Staged method '${methodName}' in class ${className} at ${this.rel(abs)}`);
+        return { staged: true, overwritten: !!existingMethod, skipped: false };
+    }
+
 }

package/src/solid-core.module.ts

@@ -102,6 +102,7 @@ import { UserSeederService } from './seeders/user-seeder.service';
 import { AuthenticationService } from './services/authentication.service';
 import { BcryptService } from './services/bcrypt.service';
 import { UuidExternalIdComputedFieldProvider } from './services/computed-fields/uuid-external-id-computed-field-provider.service';
+import { UuidExternalIdEntityComputedFieldProvider } from './services/computed-fields/entity/uuid-externalid-entity-computed-field-provider.service';
 import { EmailTemplateService } from './services/email-template.service';
 import { FileService } from './services/file.service';
 import { HashingService } from './services/hashing.service';
@@ -288,12 +289,15 @@ import { SolidCreateModuleMcpHandler } from './services/genai/mcp-handlers/solid
 import { SolidCreateModelWithFieldsMcpHandler } from './services/genai/mcp-handlers/solid-create-model-with-fields-mcp-handler.service';
 import { SolidAddFieldsToModelMcpHandler } from './services/genai/mcp-handlers/solid-add-fields-to-model-mcp-handler.service';
 import { SolidUpdateLayoutMcpHandler } from './services/genai/mcp-handlers/solid-update-layout-mcp-handler.service';
-import { SolidCreateDashboardMcpHandler } from './services/genai/mcp-handlers/solid-create-dashboard-mcp-handler.service';
+import { SolidCreateDashboardWithWidgetsMcpHandler } from './services/genai/mcp-handlers/solid-create-dashboard-mcp-handler.service';
 import { SolidCreateDashboardQuestionMcpHandler } from './services/genai/mcp-handlers/solid-create-dashboard-question-mcp-handler.service';
 import { SolidCreateDashboardQuestionSqlDatasetConfigMcpHandler } from './services/genai/mcp-handlers/solid-create-dashboard-question-sql-dataset-config-mcp-handler.service';
 import { SolidCreateDashboardWidgetMcpHandler } from './services/genai/mcp-handlers/solid-create-dashboard-widget-mcp-handler.service';
 import { SolidCreateComputedProviderMcpHandler } from './services/genai/mcp-handlers/solid-create-computed-provider-mcp-handler.service';
 import { SolidTsMorphService } from './services/solid-ts-morph.service';
+import { SolidAddVariableToDashboardMcpHandler } from './services/genai/mcp-handlers/solid-add-variable-to-dashboard-mcp-handler.service';
+import { SolidAddQuestionToDashboardMcpHandler } from './services/genai/mcp-handlers/solid-add-question-to-dashboard-mcp-handler.service';
+import { SolidAddCustomServiceMethodMcpHandler } from './services/genai/mcp-handlers/solid-add-custom-service-method-mcp-handler.service';
 
 
 @Global()
@@ -536,6 +540,7 @@ import { SolidTsMorphService } from './services/solid-ts-morph.service';
     TinyUrlService,
     PdfService,
     UuidExternalIdComputedFieldProvider,
+    UuidExternalIdEntityComputedFieldProvider,
     ListOfModelsSelectionProvider,
     ListOfScheduledJobsSelectionProvider,
     LocaleListSelectionProvider,
@@ -630,12 +635,16 @@ import { SolidTsMorphService } from './services/solid-ts-morph.service';
     SolidCreateModelWithFieldsMcpHandler,
     SolidAddFieldsToModelMcpHandler,
     SolidUpdateLayoutMcpHandler,
-
-    SolidCreateDashboardMcpHandler,
+    
+    SolidCreateDashboardWithWidgetsMcpHandler,
     SolidCreateDashboardQuestionMcpHandler,
     SolidCreateDashboardQuestionSqlDatasetConfigMcpHandler,
     SolidCreateDashboardWidgetMcpHandler,
     SolidCreateComputedProviderMcpHandler,
+    SolidAddVariableToDashboardMcpHandler,
+    SolidAddQuestionToDashboardMcpHandler,
+
+    SolidAddCustomServiceMethodMcpHandler,
     SolidTsMorphService,
 
     ViewMetadataRepository,