@solidstarters/solid-core 1.2.186 → 1.2.188

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.186",
+  "version": "1.2.188",
   "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/config/iam.config.ts

@@ -1,5 +1,4 @@
 import { registerAs } from '@nestjs/config';
-import { Environment } from 'src';
 
 export const iamConfig = registerAs('iam', () => {
     return {
@@ -14,7 +13,7 @@ export const iamConfig = registerAs('iam', () => {
         defaultRole: process.env.IAM_DEFAULT_ROLE ?? 'Public',
         dummyOtp: process.env.IAM_OTP_DUMMY,
         forgotPasswordSendVerificationTokenOn: process.env.IAM_FORGOT_PASSWORD_SEND_VERIFICATION_TOKEN_ON ?? 'email',
-        forceChangePasswordOnFirstLogin:true,
+        forceChangePasswordOnFirstLogin:false,
         PASSWORD_REGEX: process.env.PASSWORD_REGEX || '^$|^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[^\\da-zA-Z]).*$',
         PASSWORD_COMPLEXITY_DESC : process.env.PASSWORD_COMPLEXITY_DESC || 'Password must contain at least one uppercase, one lowercase, one number, and one special character.',
         googleOauth: {
@@ -29,12 +28,3 @@ export const iamConfig = registerAs('iam', () => {
     };
 })
 
-export const jwtConfig = registerAs('jwt', () => {
-    return {
-        secret: process.env.IAM_JWT_SECRET,
-        audience: process.env.IAM_JWT_TOKEN_AUDIENCE,
-        issuer: process.env.IAM_JWT_TOKEN_ISSUER,
-        accessTokenTtl: parseInt(process.env.IAM_JWT_ACCESS_TOKEN_TTL ?? (process.env.ENV as Environment) === Environment.Production ? '1200' : '86400', 10), // 20 minutes in prod, 1 day otherwise
-        refreshTokenTtl: parseInt(process.env.IAM_JWT_REFRESH_TOKEN_TTL ?? '604800', 10), // 7 days
-    };
-});

package/src/config/jwt.config.ts

@@ -0,0 +1,13 @@
+import { registerAs } from '@nestjs/config';
+import { Environment } from 'src/decorators/disallow-in-production.decorator';
+
+
+export const jwtConfig = registerAs('jwt', () => {
+    return {
+        secret: process.env.IAM_JWT_SECRET,
+        audience: process.env.IAM_JWT_TOKEN_AUDIENCE,
+        issuer: process.env.IAM_JWT_TOKEN_ISSUER,
+        accessTokenTtl: parseInt(process.env.IAM_JWT_ACCESS_TOKEN_TTL ?? (process.env.ENV as Environment) === Environment.Production ? '1200' : '86400', 10), // 20 minutes in prod, 1 day otherwise
+        refreshTokenTtl: parseInt(process.env.IAM_JWT_REFRESH_TOKEN_TTL ?? '604800', 10), // 7 days
+    };
+});

package/src/guards/access-token.guard.ts

@@ -9,7 +9,7 @@ import { ConfigType } from '@nestjs/config';
 import { JwtService } from '@nestjs/jwt';
 import { Request } from 'express';
 import { ActiveUserData } from '../interfaces/active-user-data.interface';
-import { jwtConfig } from '../config/iam.config';
+import { jwtConfig } from 'src/config/jwt.config';
 import { REQUEST_USER_KEY } from "../constants";
 import { PermissionMetadataService } from '../services/permission-metadata.service';
 import { ClsService } from 'nestjs-cls';

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

@@ -281,7 +281,14 @@ export interface IErrorCodeProvider {
 
 // MCP Tool Related
 
-export type PlanStep = CreateNewFileStep | RegisterNestProviderStep | AddMethodToExistingClassStep | RegisterSolidXExtensionComponentStep | AddListViewButtonStep;
+export type PlanStep = CreateNewFileStep | RegisterNestProviderStep | AddMethodToExistingClassStep | RegisterSolidXExtensionComponentStep | AddListViewButtonStep | AddFormViewButtonStep | AddImportStep;
+export interface AddImportStep {
+  type: "addImport";
+  path: string;                 // e.g. apps/api/src/address-master/services/address-master.service.ts
+  importStatement: string;      // e.g. import { Something } from 'somewhere';
+  overwrite?: boolean;        // default=false
+  rationale?: string;           // optional, ignored by executor
+}
 
 export interface CreateNewFileStep {
   type: "createNewFile";
@@ -307,6 +314,7 @@ export interface AddMethodToExistingClassStep {
   className: string             // e.g. CountryService
   methodName: string            // e.g. addCountry
   content: string               // Full Method Code
+  importStatements?: string[];  // e.g. [ "import { X } from 'y';" ]
   rationale?: string;           // optional, ignored by executor
 }
 
@@ -325,6 +333,14 @@ export interface AddListViewButtonStep {
   content?: string;            // Code
 }
 
+export interface AddFormViewButtonStep {
+  type: "addFormViewButton";
+  moduleName?: string;
+  modelName?: string;
+  buttonType?: string;
+  content?: string;            // Code
+}
+
 export interface McpComputedProviderResponse {
   plan: PlanStep[];
   // provider?: any;  // (intentionally ignored per your note)

package/src/jobs/database/trigger-mcp-client-subscriber-database.service.ts

@@ -142,6 +142,10 @@ export class TriggerMcpClientSubscriberDatabase extends DatabaseSubscriber<Trigg
             }
         );
 
+        const existingControllerAndTheirMethods = this.solidRegistry.getControllers();
+
+        
+
         // Build markdown sections using template interpolation
         const modulesSection = (existingModules ?? [])
             .map(m => [
@@ -176,6 +180,14 @@ export class TriggerMcpClientSubscriberDatabase extends DatabaseSubscriber<Trigg
             ].join('\n'))
             .join('\n\n');
 
+        const controllersAndTheirMethods = (existingControllerAndTheirMethods ?? [])
+            .map(m => [
+                `### ${m.name}`,
+                `- methods: ${m.methods.length ? m.methods.map(m => `- ${m}`).join('\n'): '- No methods found'}`,
+            ].join('\n'))
+            .join('\n\n');
+
+
 
         const finalPrompt = `
 # User Prompt: 
@@ -212,6 +224,12 @@ Use the below list of computed field providers to infer which provider the user
 ${computationProvidersSection}
 `.trim();
 
+
+// ## LIST OF EXISTING CONTROLLERS AND THEIR METHODS
+// Use the below list of controllers and their methods to infer whether the api call being made to a particular controller exists or not.
+
+// ${controllersAndTheirMethods}
+
         const aiResponse = await this.aiInteractionService.runMcpPrompt(finalPrompt);
         this.triggerMcpClientSubscriberLogger.log(`aiResponse: `);
         this.triggerMcpClientSubscriberLogger.log(JSON.stringify(aiResponse));

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/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,