@solidstarters/solid-core 1.2.187 → 1.2.189

package/src/services/authentication.service.ts

@@ -15,10 +15,21 @@ import { JwtService } from '@nestjs/jwt';
 import { InjectDataSource, InjectRepository } from '@nestjs/typeorm';
 import { isEmpty, isNotEmpty } from 'class-validator';
 import { randomInt, randomUUID } from 'crypto';
-import { SMTPEMailService } from 'src/services/mail/smtp-email.service';
+import commonConfig from 'src/config/common.config';
+import { jwtConfig } from 'src/config/jwt.config';
+import { ERROR_MESSAGES } from 'src/constants/error-messages';
+import { SUCCESS_MESSAGES } from 'src/constants/success-messages';
+import { CreateUserDto } from 'src/dtos/create-user.dto';
+import { MailFactory } from 'src/factories/mail.factory';
 import { Msg91OTPService } from 'src/services/sms/Msg91OTPService';
 import { DataSource, Repository } from 'typeorm';
-import { iamConfig, jwtConfig } from '../config/iam.config';
+import { v4 as uuidv4 } from 'uuid';
+import { iamConfig } from '../config/iam.config';
+import {
+    ForgotPasswordSendVerificationTokenOn,
+    RegistrationValidationSource,
+    TransactionalRegistrationValidationSource
+} from "../constants";
 import { ChangePasswordDto } from "../dtos/change-password.dto";
 import { ConfirmForgotPasswordDto } from '../dtos/confirm-forgot-password.dto';
 import { InitiateForgotPasswordDto } from '../dtos/initiate-forgot-password.dto';
@@ -29,26 +40,15 @@ import { RefreshTokenDto } from '../dtos/refresh-token.dto';
 import { SignInDto } from '../dtos/sign-in.dto';
 import { SignUpDto } from '../dtos/sign-up.dto';
 import { User } from '../entities/user.entity';
+import { EventDetails, EventType } from "../interfaces";
 import { ActiveUserData } from '../interfaces/active-user-data.interface';
 import { HashingService } from './hashing.service';
 import { InvalidatedRefreshTokenError, RefreshTokenIdsStorageService } from './refresh-token-ids-storage.service';
-import { UserService } from './user.service';
-import { EventDetails, EventType, IMail } from "../interfaces";
-import {
-    ForgotPasswordSendVerificationTokenOn,
-    RegistrationValidationSource,
-    TransactionalRegistrationValidationSource
-} from "../constants";
-import { SettingService } from './setting.service';
-import { CreateUserDto } from 'src/dtos/create-user.dto';
+import { RequestContextService } from './request-context.service';
 import { RoleMetadataService } from './role-metadata.service';
-import commonConfig from 'src/config/common.config';
+import { SettingService } from './setting.service';
 import { UserActivityHistoryService } from './user-activity-history.service';
-import { RequestContextService } from './request-context.service';
-import { ERROR_MESSAGES } from 'src/constants/error-messages';
-import { SUCCESS_MESSAGES } from 'src/constants/success-messages';
-import { MailFactory } from 'src/factories/mail.factory';
-import { v4 as uuidv4 } from 'uuid';
+import { UserService } from './user.service';
 
 enum LoginProvider {
     LOCAL = 'local',

package/src/services/crud.service.ts

@@ -655,14 +655,9 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         return entity;
     }
 
-    async insertMany(createDtos: any[], filesArray: Express.Multer.File[][] = [], solidRequestContext: any = {}): Promise<T[]> {
-
-
-        // if (createDtos.length !== filesArray.length) {
-        //     throw new BadRequestException('Mismatch between data objects and file arrays.');
-        // }
-
+    async createMany(createDtos: any[], solidRequestContext: any = {}): Promise<T[]> {
         const loadedmodel = await this.loadModel();
+
         // Check wheather user has create permission for model
         if (solidRequestContext.activeUser) {
             const hasPermission = this.crudHelperService.hasCreatePermissionOnModel(solidRequestContext.activeUser, loadedmodel.singularName);
@@ -680,37 +675,28 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
             module: true,
         });
 
-        // Process each createDto in parallel
-        const createAndSavePromises = createDtos.map(async (createDto, index) => {
-            const files = []; // TODO, This is set, because we are not supporting files for insertMany currently
-            let hasMediaFields = false;
-
-            // Process each field
+        const entitiesForSave: T[] = [];
+        for (const createDto of createDtos) {
+            // Validate and transform each createDto sequentially
+            let transformedDto = createDto;
             for (const field of model.fields) {
                 const fieldManager: FieldCrudManager = await this.fieldCrudManager(field, this.entityManager);
-                const validationErrors = await fieldManager.validate(createDto, files);
+                const validationErrors = await fieldManager.validate(createDto, []); // TODO, This is set, because we are not supporting files for insertMany currently
                 if (validationErrors.length > 0) {
                     throw new BadRequestException(`Validation errors in ${field.name} are invalid: ${validationErrors.map(e => e.error).join(', ')}`);
                 }
-                createDto = await fieldManager.transformForCreate(createDto);
-                hasMediaFields = hasMediaFields || field.type === 'mediaSingle' || field.type === 'mediaMultiple';
+                transformedDto = await fieldManager.transformForCreate(createDto);
             }
+            const entity = this.repo.create(transformedDto);
+            entitiesForSave.push(entity as T);
+        }
+        // Save all entities in a single batch
+        const savedEntities = await this.repo.save(entitiesForSave) as T[];
+        return savedEntities;
+    }
 
-            // Save the entity
-            const entity = this.repo.create(createDto);
-            const savedEntity = await this.repo.save(entity) as T;
-
-            //Commented since currently Files are not supported for insertmany
-            // if (hasMediaFields) {
-            //     await this.saveMedia(model, files, savedEntity);
-            // }
-
-            return savedEntity;
-        });
-
-        // Await all promises in parallel
-        const savedEntities = await Promise.all(createAndSavePromises);
-
+    async insertMany(createDtos: any[], filesArray: Express.Multer.File[][] = [], solidRequestContext: any = {}): Promise<T[]> {
+        const savedEntities = await this.createMany(createDtos, solidRequestContext);
         return savedEntities;
     }
 

package/src/services/dashboard-question.service.ts

@@ -82,6 +82,7 @@ export class DashboardQuestionService extends CRUDService<DashboardQuestion> {
 
   private getExpressions(isPreview: boolean, dashboardVariables: DashboardVariable[], inputExpressions: SqlExpression[]) {
     const expressions: SqlExpression[] = [];
+
     if (isPreview) {
       // Convert the dashboard variables into objects of interface type SqlExpression using the default value, default operator and the variable name
       const expr: SqlExpression[] = dashboardVariables.map(variable => {
@@ -94,9 +95,35 @@ export class DashboardQuestionService extends CRUDService<DashboardQuestion> {
       expressions.push(...expr);
     }
     else {
-      expressions.push(...inputExpressions);
+      // Loop through the dashboard variables and see if there is a matching input expression
+      // If there is, use that expression instead of the default value
+      for (const variable of dashboardVariables) {
+        const matchingInputExpression = inputExpressions.find(expr => expr.variableName === variable.variableName);
+        if (matchingInputExpression) {
+          expressions.push(matchingInputExpression);
+        }
+        else {
+          expressions.push({
+            variableName: variable.variableName,
+            operator: variable.defaultOperator as SqlExpressionOperator,
+            value: JSON.parse(variable.defaultValue || '[]'),
+          });
+        }
+      }
+      expressions.push(...expressions);
+    }
+
+    // Remove duplicate expressions based on variableName in the expressions array
+    const deduplicatedExpressions: SqlExpression[] = [];
+    const variableNames = new Set<string>();
+    for (const expr of expressions) {
+      if (!variableNames.has(expr.variableName)) {
+        deduplicatedExpressions.push(expr);
+        variableNames.add(expr.variableName);
+      }
     }
-    return expressions;
+
+    return deduplicatedExpressions;
   }
 
   private async loadQuestion(id: number) {

package/src/services/genai/mcp-handlers/solid-add-button-to-form-view-mcp-handler.service.ts

@@ -0,0 +1,137 @@
+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 SolidAddButtonToFormViewMcpHandler implements IMcpToolResponseHandler {
+    private readonly logger = new Logger(SolidAddButtonToFormViewMcpHandler.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("SolidAddButtonToFormViewMcpHandler: 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 "addFormViewButton": {
+
+                        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 === "form" &&
+                                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/genai/mcp-handlers/solid-add-controller-handler-method-mcp-handler.service.ts

@@ -1,6 +1,6 @@
 import { Injectable, Logger } from "@nestjs/common";
 import { AiInteraction } from "src/entities/ai-interaction.entity";
-import { IMcpToolResponseHandler, McpComputedProviderResponse, PlanStep } from "../../../interfaces";
+import { AddMethodToExistingClassStep, IMcpToolResponseHandler, McpComputedProviderResponse, PlanStep } from "../../../interfaces";
 import { SolidTsMorphService } from "src/services/solid-ts-morph.service";
 
 @Injectable()
@@ -28,12 +28,7 @@ export class SolidAddControllerHandlerMcpHandler implements IMcpToolResponseHand
             break;
           }
           case "addMethodToExistingClass": {
-            this.tsMorph.addMethodToExistingClass(
-              step.path,
-              step.className,
-              step.methodName,
-              step.content,
-            );
+            this.handleAddMethodToExistingClass(step);
             break;
           }
           default:
@@ -64,4 +59,23 @@ export class SolidAddControllerHandlerMcpHandler implements IMcpToolResponseHand
       return JSON.parse(unescaped);
     }
   }
+
+  private handleAddMethodToExistingClass(step: PlanStep) {
+    // Cast step to the appropriate type if necessary
+    const addMethodStep = step as AddMethodToExistingClassStep
+    // Add the import statement to the specified file
+    if (addMethodStep.importStatements && addMethodStep.importStatements.length > 0) {
+      this.tsMorph.addImport(
+        addMethodStep.path,
+        (addMethodStep.importStatements || []).join('\n'),
+      );
+    }
+    // Add the method content to the specified class in the file
+    this.tsMorph.addMethodToExistingClass(
+      addMethodStep.path,
+      addMethodStep.className,
+      addMethodStep.methodName,
+      addMethodStep.content,
+    );
+  }
 }

package/src/services/genai/mcp-handlers/solid-create-custom-form-view-widget-mcp-handler.service.ts

@@ -0,0 +1,72 @@
+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 SolidCreateCustomFormViewWidgetMcpHandler implements IMcpToolResponseHandler {
+    private readonly logger = new Logger(SolidCreateCustomFormViewWidgetMcpHandler.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("SolidCreateCustomFormViewWidgetMcpHandler: 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;
+                    }
+                    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/list-of-values-metadata.service.ts

@@ -111,8 +111,6 @@ export class ListOfValuesMetadataService extends CRUDService<ListOfValues> {
     await this.deleteFromConfig(metaData, listofvalue, filePath);
   }
 
-
-
   private async getConfigFileDetails(moduleName: string): Promise<{ filePath: string; metaData: any }> {
     const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(moduleName);
     try {
@@ -185,7 +183,6 @@ export class ListOfValuesMetadataService extends CRUDService<ListOfValues> {
     await fs.writeFile(filePath, updatedContent);
   }
 
-
   private async deleteFromConfig(metaData: any, listofvalues: ListOfValues, filePath: string) {
     const dto = await this.listOfValuesMapper.toDto(listofvalues);
 

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

@@ -1045,8 +1045,8 @@ export class ModelMetadataService {
     let view = await viewRepo.findOne({ where: { name: `${model.singularName}-list-view` } });
 
     const actionData = {
-      displayName: `${model.displayName} List View`,
-      name: `${model.singularName}-list-view`,
+      displayName: `${model.displayName} List Action`,
+      name: `${model.singularName}-list-action`,
       type: "solid",
       domain: "" as any,
       context: "" as any,

package/src/services/selection-providers/list-of-models-selection-provider.service.ts

@@ -33,7 +33,7 @@ export class ListOfModelsSelectionProvider implements ISelectionProvider<ISelect
         const models = (await this.modelMetadataService.findMany(queryData)).records;
 
         const model = models.filter(i => i.singularName === optionValue)[0];
-        return { label: model.singularName, value: model.id }
+        return { label: model.displayName, value: model.singularName }
     }
 
     async values(query: string, ctxt: ISelectionProviderContext): Promise<readonly ISelectionProviderValues[]> {
@@ -63,7 +63,7 @@ export class ListOfModelsSelectionProvider implements ISelectionProvider<ISelect
         // });
 
         return filteredModels.map(i => {
-            return { label: i.singularName, value: i.singularName };
+            return { label: i.displayName, value: i.singularName };
         });
 
     }

package/src/services/setting.service.ts

@@ -77,7 +77,8 @@ export class SettingService extends CRUDService<Setting> {
             defaultProvider: "",
             availableProviders: []
         }),
-      showNameFieldsForRegistration:this.iamConfiguration.showNameFieldsForRegistration
+      showNameFieldsForRegistration:this.iamConfiguration.showNameFieldsForRegistration,
+      forceChangePasswordOnFirstLogin: this.iamConfiguration.forceChangePasswordOnFirstLogin
     };
 
     const existingSettings = await this.repo.find();
@@ -175,7 +176,7 @@ export class SettingService extends CRUDService<Setting> {
       shouldQueueSms: this.commonConfiguration.shouldQueueSms,
       enableDarkMode: true,
       copyright: null,
-      forceChangePasswordOnFirstLogin: true,
+      forceChangePasswordOnFirstLogin: this.iamConfiguration.forceChangePasswordOnFirstLogin,
       enableUsername: true,
       enabledNotification: true,
       contactSupportEmail : null,

package/src/solid-core.module.ts

@@ -57,7 +57,8 @@ import { HttpModule } from '@nestjs/axios';
 import { JwtModule } from '@nestjs/jwt';
 import { SeedCommand } from './commands/seed.command';
 import commonConfig from './config/common.config';
-import { iamConfig, jwtConfig } from './config/iam.config';
+import { iamConfig } from './config/iam.config';
+import { jwtConfig } from './config/jwt.config';
 import { AuthenticationController } from './controllers/authentication.controller';
 import { EmailTemplateController } from './controllers/email-template.controller';
 import { GoogleAuthenticationController } from './controllers/google-authentication.controller';
@@ -300,6 +301,8 @@ import { SolidAddQuestionToDashboardMcpHandler } from './services/genai/mcp-hand
 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';
+import { SolidAddButtonToFormViewMcpHandler } from './services/genai/mcp-handlers/solid-add-button-to-form-view-mcp-handler.service';
+import { SolidCreateCustomFormViewWidgetMcpHandler } from './services/genai/mcp-handlers/solid-create-custom-form-view-widget-mcp-handler.service';
 
 
 @Global()
@@ -649,6 +652,9 @@ import { SolidAddControllerHandlerMcpHandler } from './services/genai/mcp-handle
     SolidAddCustomServiceMethodMcpHandler,
     SolidAddHeaderButtonOrRowButtonToListViewMcpHandler,
     SolidAddControllerHandlerMcpHandler,
+    SolidAddButtonToFormViewMcpHandler,
+    SolidCreateCustomFormViewWidgetMcpHandler,
+    
     SolidTsMorphService,
 
     ViewMetadataRepository,