@solidstarters/solid-core 1.2.185 → 1.2.187

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.185",
+  "version": "1.2.187",
   "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/selection-dynamic-query.dto.ts

@@ -26,4 +26,8 @@ export class SelectionDynamicQueryDto extends PaginationQueryDto {
     @IsString()
     @IsOptional()
     optionValue?: string = '';
+
+    @ApiProperty({ description: "Form Values", type: Object })
+    @IsOptional()
+    formValues: Record<string, any>;
 }

package/src/helpers/module-metadata-helper.service.ts

@@ -16,8 +16,15 @@ export class ModuleMetadataHelperService {
     // }
 
     async getModuleMetadataConfiguration(configFilePath: string): Promise<any> {
-        const fileContent = await fs.readFile(configFilePath, 'utf8');
-        return JSON.parse(fileContent);
+        try {
+            const fileContent = await fs.readFile(configFilePath, 'utf8');
+            return JSON.parse(fileContent);
+        }
+        catch (error) {
+            this.logger.error(`module metadata configuration non existent at: ${configFilePath}`);
+        }
+
+        return null;
     }
 
     async getModulePath(moduleName: string): Promise<string> {
@@ -30,7 +37,7 @@ export class ModuleMetadataHelperService {
         const filePath = path.join(folderPath, `${dashModuleName}-metadata.json`);
         // Check if filePath exists
         const fileExists = await this.fileService.fileExists(filePath);
-        this.logger.debug(`File exists: ${fileExists} at ${filePath}`);
+        // this.logger.debug(`File exists: ${fileExists} at ${filePath}`);
         if (!fileExists) {
             // If the module is solid-core, try the fallback path, in case the current root directory is the solid core project
             if (dashModuleName === SOLID_CORE_MODULE_NAME) {

package/src/index.ts

@@ -24,6 +24,7 @@ export * from './decorators/solid-database-module.decorator'
 export * from './decorators/solid-service.decorator'
 export * from './decorators/mail-provider.decorator'
 
+export * from './dtos/post-chatter-message.dto'
 export * from './dtos/basic-filters.dto'
 export * from './dtos/solid-request-context.dto'
 export * from './dtos/change-password.dto'

package/src/interfaces.ts

@@ -83,6 +83,9 @@ export interface McpResponse {
 }
 
 export interface ISelectionProviderContext {
+  limit: number;
+  offset: number;
+  formValues: Record<string, any>;
   // query: string;
 }
 
@@ -278,7 +281,7 @@ export interface IErrorCodeProvider {
 
 // MCP Tool Related
 
-export type PlanStep = CreateNewFileStep | RegisterNestProviderStep | AddMethodToExistingClassStep;
+export type PlanStep = CreateNewFileStep | RegisterNestProviderStep | AddMethodToExistingClassStep | RegisterSolidXExtensionComponentStep | AddListViewButtonStep;
 
 export interface CreateNewFileStep {
   type: "createNewFile";
@@ -307,7 +310,20 @@ export interface AddMethodToExistingClassStep {
   rationale?: string;           // optional, ignored by executor
 }
 
+export interface RegisterSolidXExtensionComponentStep {
+  type: "registerSolidXExtensionComponent";
+  path: string;                 // e.g. apps/api/src/address-master/services/address-master.service.ts
+  content?: string;               // Code
+  importExtensionComponent?: string;
+}
 
+export interface AddListViewButtonStep {
+  type: "addListViewButton";
+  moduleName?: string;
+  modelName?: string;
+  buttonType?: string;
+  content?: string;            // Code
+}
 
 export interface McpComputedProviderResponse {
   plan: PlanStep[];

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

@@ -15,6 +15,7 @@ import { ModelMetadata } from '../entities/model-metadata.entity';
 import { ISelectionProviderValues } from '../interfaces';
 import { CrudHelperService } from './crud-helper.service';
 import { ERROR_MESSAGES } from 'src/constants/error-messages';
+import qs from 'qs';
 
 
 @Injectable()
@@ -1046,6 +1047,11 @@ export class FieldMetadataService implements OnApplicationBootstrap {
         const selectionDynamicProviderCtxt = JSON.parse(entity.selectionDynamicProviderCtxt ? entity.selectionDynamicProviderCtxt : '{}');
         selectionDynamicProviderCtxt['limit'] = query.limit;
         selectionDynamicProviderCtxt['offset'] = query.offset;
+        const formValues = query.formValues || {};
+        // Parse the form values if they are in string format using qs
+        const parsedFormValues = typeof formValues === 'string' ? qs.parse(formValues, { allowDots: true }) : formValues;
+        selectionDynamicProviderCtxt['formValues'] = parsedFormValues;
+
 
         // 3. get hold of the provider instance from the SolidRegistry
         const selectionProviderInstance = this.solidRegistry.getSelectionProviderInstance(selectionDynamicProvider);
@@ -1073,6 +1079,10 @@ export class FieldMetadataService implements OnApplicationBootstrap {
         const selectionDynamicProviderCtxt = JSON.parse(entity.selectionDynamicProviderCtxt ? entity.selectionDynamicProviderCtxt : '{}');
         selectionDynamicProviderCtxt['limit'] = query.limit;
         selectionDynamicProviderCtxt['offset'] = query.offset;
+        const formValues = query.formValues || {};
+        // Parse the form values if they are in string format using qs
+        const parsedFormValues = typeof formValues === 'string' ? qs.parse(formValues, { allowDots: true }) : formValues;
+        selectionDynamicProviderCtxt['formValues'] = parsedFormValues;
 
         // 3. get hold of the provider instance from the SolidRegistry
         const selectionProviderInstance = this.solidRegistry.getSelectionProviderInstance(selectionDynamicProvider);

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

@@ -0,0 +1,67 @@
+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";
+
+@Injectable()
+export class SolidAddControllerHandlerMcpHandler implements IMcpToolResponseHandler {
+  private readonly logger = new Logger(SolidAddControllerHandlerMcpHandler.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("SolidAddControllerHandlerMethodMcpHandler: 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: true,
+        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-header-button-or-row-button-to-list-view-mcp-handler.service.ts

@@ -0,0 +1,141 @@
+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";
+import { ModuleMetadataHelperService } from "src/helpers/module-metadata-helper.service";
+import * as fs from "fs/promises";
+
+const RESTART_TOUCH_FILE = process.env.MCP_RESTART_TOUCH_FILE || "tmp/restart.touch";
+
+@Injectable()
+export class SolidAddHeaderButtonOrRowButtonToListViewMcpHandler implements IMcpToolResponseHandler {
+    private readonly logger = new Logger(SolidAddHeaderButtonOrRowButtonToListViewMcpHandler.name);
+
+    constructor(
+        private readonly tsMorph: SolidTsMorphService,
+        private readonly moduleMetadataHelperService: ModuleMetadataHelperService,
+
+    ) { }
+
+    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("SolidAddHeaderButtonOrRowButtonToListViewMcpHandler: 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 "registerSolidXExtensionComponent": {
+                        this.tsMorph.registerSolidUiExtension(
+                            step.path,
+                            step.content,
+                        );
+                        this.tsMorph.addImport(
+                            step.path,
+                            step.importExtensionComponent,
+                        );
+                        break;
+                    }
+                    case "addListViewButton": {
+
+                        const filePath =
+                            await this.moduleMetadataHelperService.getModuleMetadataFilePath(
+                                step.moduleName
+                            );
+                        try {
+                            await fs.access(filePath);
+                        } catch {
+                            this.logger.error(`Metadata file not found: ${filePath}`);
+                            return;
+                        }
+                        const metaData =
+                            await this.moduleMetadataHelperService.getModuleMetadataConfiguration(
+                                filePath
+                            );
+                        // Remove, update or insert logic
+
+
+                        // Find the existing view of type "list" for the given module & model
+                        const existingViewIndex = metaData.views.findIndex(
+                            (view: any) =>
+                                view.type === "list" &&
+                                view.moduleUserKey === step.moduleName &&
+                                view.modelUserKey === step.modelName
+                        );
+
+                        if (existingViewIndex !== -1) {
+                            const view = metaData.views[existingViewIndex];
+
+                            // Ensure layout & attrs exist
+                            view.layout = view.layout || {};
+                            view.layout.attrs = view.layout.attrs || {};
+
+                            // Initialize rowButtons or headerButtons if not present
+                            if (!Array.isArray(view.layout.attrs[step.buttonType])) {
+                                view.layout.attrs[step.buttonType] = [];
+                            }
+
+                            let buttonContent = step.content;
+
+                            // Parse only if it’s a string
+                            if (typeof buttonContent === "string") {
+                                try {
+                                    buttonContent = JSON.parse(buttonContent);
+                                } catch (err) {
+                                    this.logger.error("❌ Failed to parse step.content JSON:", err);
+                                    return;
+                                }
+                            }
+
+
+                            // Push the new button content
+                            view.layout.attrs[step.buttonType].push(buttonContent);
+
+                            console.log(`✅ Added ${step.buttonType} to view: ${view.name}`);
+                        } else {
+                            console.warn(`⚠️ No matching list view found for module=${step.moduleName} and model=${step.modelName}`);
+                        }
+
+                        const updatedContent = JSON.stringify(metaData, null, 2);
+                        await fs.writeFile(filePath, updatedContent);
+                        this.logger.log(`Updated list view in ${filePath}`);
+
+                        break;
+                    }
+                    default:
+                        throw new Error(`Unsupported plan step type: ${(step as any).type}`);
+                }
+            }
+
+            const result = await this.tsMorph.commit();
+
+            return {
+                seedingRequired: true,
+                serverRebooting: false,
+            };
+        } 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/model-metadata.service.ts

@@ -657,28 +657,30 @@ export class ModelMetadataService {
     // <moduleName>-metadata.json | Remove references to this model in the model metadata, menu, action & view sections. | Automatic
     const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(modelEntity.module.name);
     const metaData = await this.moduleMetadataHelperService.getModuleMetadataConfiguration(filePath);
-    const existingModelIndex = metaData.moduleMetadata.models.findIndex(
-      (existingModel: any) => existingModel.singularName === modelEntity.singularName
-    );
+    if (metaData) {
+      const existingModelIndex = metaData.moduleMetadata.models.findIndex(
+        (existingModel: any) => existingModel.singularName === modelEntity.singularName
+      );
 
-    // Remove the model to be deleted from the metadata
-    if (existingModelIndex !== -1) {
-      metaData.moduleMetadata.models.splice(existingModelIndex, 1);
-    }
+      // Remove the model to be deleted from the metadata
+      if (existingModelIndex !== -1) {
+        metaData.moduleMetadata.models.splice(existingModelIndex, 1);
+      }
 
-    // Remove references to this model in the menu, action & view sections.
-    metaData.moduleMetadata.menus = metaData.moduleMetadata.menus.filter(
-      (menu: any) => menu.modelUserKey !== modelEntity.singularName
-    );
-    metaData.moduleMetadata.actions = metaData.moduleMetadata.actions.filter(
-      (action: any) => action.modelUserKey !== modelEntity.singularName
-    );
-    metaData.moduleMetadata.views = metaData.moduleMetadata.views.filter(
-      (view: any) => view.modelUserKey !== modelEntity.singularName
-    );
+      // Remove references to this model in the menu, action & view sections.
+      metaData.moduleMetadata.menus = metaData.moduleMetadata.menus.filter(
+        (menu: any) => menu.modelUserKey !== modelEntity.singularName
+      );
+      metaData.moduleMetadata.actions = metaData.moduleMetadata.actions.filter(
+        (action: any) => action.modelUserKey !== modelEntity.singularName
+      );
+      metaData.moduleMetadata.views = metaData.moduleMetadata.views.filter(
+        (view: any) => view.modelUserKey !== modelEntity.singularName
+      );
 
-    const updatedContent = JSON.stringify(metaData, null, 2);
-    await fs.writeFile(filePath, updatedContent);
+      const updatedContent = JSON.stringify(metaData, null, 2);
+      await fs.writeFile(filePath, updatedContent);
+    }
 
     // <moduleName>.module.ts | Remove all references and imports of the above files. | Manual (X)
     // const moduleFilePath = path.resolve(modulePath, `${dasherize(modelEntity.module.name)}.module.ts`);

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

@@ -297,4 +297,79 @@ export class SolidTsMorphService {
         return { staged: true, overwritten: !!existingMethod, skipped: false };
     }
 
+    registerSolidUiExtension(
+        filePath: string,
+        lineToAdd: string
+    ): { staged: boolean; overwritten: boolean; skipped: boolean } {
+        const abs = this.resolveRepoPath(filePath);
+        if (!existsSync(abs))
+            throw new Error(`registerSolidUiExtension: File not found at ${filePath}`);
+
+        const fileContent = readFileSync(abs, "utf8");
+
+        // Check if the line already exists (avoid duplicates)
+        if (fileContent.includes(lineToAdd.trim())) {
+            this.logger.log(`Skipped adding line (already exists): ${lineToAdd}`);
+            return { staged: false, overwritten: false, skipped: true };
+        }
+
+        // Append the new line at the end, ensuring newline
+        const newContent = fileContent.trimEnd() + "\n" + lineToAdd.trim() + "\n";
+
+        // Write updated content back
+        writeFileSync(abs, newContent, "utf8");
+
+        this.dirtySourceFiles.add(abs);
+        this.logger.log(`Staged new line in ${this.rel(abs)}: ${lineToAdd}`);
+        return { staged: true, overwritten: false, skipped: false };
+    }
+
+    addImport(
+        filePath: string,
+        importLine: string
+    ): { staged: boolean; overwritten: boolean; skipped: boolean } {
+        const abs = this.resolveRepoPath(filePath);
+        if (!existsSync(abs))
+            throw new Error(`addImport: File not found at ${filePath}`);
+
+        let fileContent = readFileSync(abs, "utf8");
+
+        // If import already exists — skip
+        if (fileContent.includes(importLine.trim())) {
+            this.logger.log(`Skipped adding import (already exists): ${importLine}`);
+            return { staged: false, overwritten: false, skipped: true };
+        }
+
+        // Find last import statement (so we can insert after all imports)
+        const importRegex = /^import .+ from .+;$/gm;
+        let lastImportMatch: RegExpExecArray | null;
+        let lastImportIndex = -1;
+
+        while ((lastImportMatch = importRegex.exec(fileContent)) !== null) {
+            lastImportIndex = lastImportMatch.index + lastImportMatch[0].length;
+        }
+
+        // Insert after last import (or at top if none exist)
+        let newContent: string;
+        if (lastImportIndex !== -1) {
+            newContent =
+                fileContent.slice(0, lastImportIndex) +
+                "\n" +
+                importLine.trim() +
+                "\n" +
+                fileContent.slice(lastImportIndex);
+        } else {
+            // No imports found — insert at top
+            newContent = importLine.trim() + "\n\n" + fileContent;
+        }
+
+        writeFileSync(abs, newContent, "utf8");
+
+        this.dirtySourceFiles.add(abs);
+        this.logger.log(`Staged import in ${this.rel(abs)}: ${importLine}`);
+        return { staged: true, overwritten: false, skipped: false };
+    }
+
+
+
 }

package/src/solid-core.module.ts

@@ -298,6 +298,8 @@ 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';
+import { SolidAddHeaderButtonOrRowButtonToListViewMcpHandler } from './services/genai/mcp-handlers/solid-add-header-button-or-row-button-to-list-view-mcp-handler.service';
+import { SolidAddControllerHandlerMcpHandler } from './services/genai/mcp-handlers/solid-add-controller-handler-method-mcp-handler.service';
 
 
 @Global()
@@ -645,6 +647,8 @@ import { SolidAddCustomServiceMethodMcpHandler } from './services/genai/mcp-hand
     SolidAddQuestionToDashboardMcpHandler,
 
     SolidAddCustomServiceMethodMcpHandler,
+    SolidAddHeaderButtonOrRowButtonToListViewMcpHandler,
+    SolidAddControllerHandlerMcpHandler,
     SolidTsMorphService,
 
     ViewMetadataRepository,

package/src/controllers/user.controller.ts.bkp

@@ -1,78 +0,0 @@
-import { Body, Controller, Delete, Get, Param, ParseIntPipe, Post, Query } from '@nestjs/common';
-import { ApiBearerAuth, ApiForbiddenResponse, ApiQuery, ApiTags } from '@nestjs/swagger';
-import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
-import { PaginationQueryDto } from 'src/dtos/pagination-query.dto';
-import { ActiveUser } from '../decorators/active-user.decorator';
-import { UserService } from '../services/user.service';
-import { MutateUserRolesDto } from '../dtos/mutate-user-roles.dto';
-import { MutateUserRolesBulkDto } from '../dtos/mutate-user-roles-list.dto';
-import { BasicFilterDto } from 'src/dtos/basic-filters.dto';
-
-@Controller('users')
-@ApiTags("Iam")
-export class UserController {
-    constructor(
-        private readonly userService: UserService
-    ) { }
-
-    // /api/users
-    @ApiBearerAuth("jwt")
-    @Get()
-    @ApiBearerAuth("jwt")
-    @ApiQuery({ name: 'limit', required: false, type: Number })
-    @ApiQuery({ name: 'offset', required: false, type: Number })
-    @ApiQuery({ name: 'fields', required: false, type: Array })
-    @ApiQuery({ name: 'sort', required: false, type: Array })
-    @ApiQuery({ name: 'groupBy', required: false, type: Array })
-    @ApiQuery({ name: 'populate', required: false, type: Array })
-    @ApiQuery({ name: 'populateMedia', required: false, type: Array })
-    @ApiQuery({ name: 'filters', required: false, type: Array })
-    async findMany(
-        @Query() basicFilterDto: BasicFilterDto,
-        @ActiveUser() activeUser: ActiveUserData,
-    ) {
-        return this.userService.findMany(basicFilterDto);
-    }
-
-    // /api/users/:id
-    @ApiBearerAuth("jwt")
-    @ApiForbiddenResponse({ description: 'Forbidden.' })
-    @Get(':id')
-    findOne(@Param('id', ParseIntPipe) id: number) {
-        return this.userService.findOne(id);
-    }
-
-    @ApiBearerAuth("jwt")
-    @ApiForbiddenResponse({ description: 'Forbidden.' })
-    @Post('roles')
-    addRoleToUser(@Body() mutateUserRoles: MutateUserRolesDto) {
-        return this.userService.addRoleToUser(mutateUserRoles.username, mutateUserRoles.roleName);
-    }
-
-    @ApiBearerAuth("jwt")
-    @ApiForbiddenResponse({ description: 'Forbidden.' })
-    @Post('roles/bulk')
-    addRolesToUser(@Body() mutateUserRolesBulk: MutateUserRolesBulkDto) {
-        return this.userService.addRolesToUser(mutateUserRolesBulk.username, mutateUserRolesBulk.roleNames);
-    }
-
-    @ApiBearerAuth("jwt")
-    @ApiForbiddenResponse({ description: 'Forbidden.' })
-    @Delete('roles')
-    removeRoleFromUser(userEmail: string, roleName: string) {
-        return this.userService.removeRoleFromUser(userEmail, roleName);
-    }
-
-    @ApiBearerAuth("jwt")
-    @Delete('/bulk')
-    async deleteMany(@Body() ids: number[]) {
-      return this.userService.deleteMany(ids);
-    }
-  
-  
-    @ApiBearerAuth("jwt")
-    @Delete(':id')
-    remove(@Param('id') id: number) {
-      return this.userService.remove(id);
-    }
-}