@solidstarters/solid-core 1.2.152 → 1.2.154

package/src/services/authentication.service.ts

@@ -12,12 +12,12 @@ import {
 import { ConfigType } from '@nestjs/config';
 import { EventEmitter2 } from '@nestjs/event-emitter';
 import { JwtService } from '@nestjs/jwt';
-import { InjectRepository } from '@nestjs/typeorm';
+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 { Msg91OTPService } from 'src/services/sms/Msg91OTPService';
-import { Repository } from 'typeorm';
+import { DataSource, Repository } from 'typeorm';
 import { iamConfig, jwtConfig } from '../config/iam.config';
 import { ChangePasswordDto } from "../dtos/change-password.dto";
 import { ConfirmForgotPasswordDto } from '../dtos/confirm-forgot-password.dto';
@@ -49,7 +49,7 @@ 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';
 
 enum LoginProvider {
     LOCAL = 'local',
@@ -88,9 +88,11 @@ export class AuthenticationService {
         private readonly commonConfiguration: ConfigType<typeof commonConfig>,
         private readonly userActivityHistoryService: UserActivityHistoryService,
         private readonly requestContextService: RequestContextService,
+        @InjectDataSource()
+        private readonly dataSource: DataSource,
     ) {
         // this.mailService = this.mailServiceFactory.getMailService();
-     }
+    }
 
     private async getConfig(key: string): Promise<any> {
         return this.settingService.getConfigValue(key);
@@ -112,6 +114,13 @@ export class AuthenticationService {
         });
     }
 
+    async resolveUserByVerificationToken(token: string) {
+        return await this.userRepository.findOne({
+            where: { verificationTokenOnForgotPassword: token },
+            relations: { roles: true }
+        });
+    }
+
     async validateUser(signInDto: SignInDto) {
 
         const user = await this.resolveUser(signInDto.username, signInDto.email);
@@ -729,6 +738,19 @@ export class AuthenticationService {
         return true;
     }
 
+    // generate uuid token for forgot password
+    private generateForgotPasswordToken() {
+        const expiryTime = new Date();
+        expiryTime.setMinutes(expiryTime.getMinutes() + this.iamConfiguration.forgotPasswordVerificationTokenExpiry);
+
+        return {
+            token: this.iamConfiguration.dummyOtp
+                ? this.iamConfiguration.dummyOtp
+                : uuidv4(),   // UUID instead of numeric OTP
+            expiresAt: expiryTime,
+        };
+    }
+
     async initiateForgotPassword(initiateForgotPasswordDto: InitiateForgotPasswordDto) {
         // Steps / Algorithm: 
         // 1. Identify the user using the specified "username", if not found exit.
@@ -738,20 +760,20 @@ export class AuthenticationService {
         const user = await this.resolveUser(initiateForgotPasswordDto.username, initiateForgotPasswordDto.email);
 
         if (!user) {
-            throw new NotFoundException(ERROR_MESSAGES.USER_NOT_FOUND);
+            throw new NotFoundException(ERROR_MESSAGES.INVALID_CREDENTIALS);
         }
         if (!user.active) {
-            throw new UnauthorizedException(ERROR_MESSAGES.USER_INACTIVE);
+            throw new UnauthorizedException(ERROR_MESSAGES.INVALID_CREDENTIALS);
         }
 
         // 2. Validate if user has used a provider which is "local", only then it makes sense for us to initiate the forgot password routine. 
         if (user.lastLoginProvider !== 'local') {
-            throw new BadRequestException(ERROR_MESSAGES.NON_LOCAL_PROVIDER);
+            throw new BadRequestException(ERROR_MESSAGES.INVALID_CREDENTIALS);
         }
 
         // 3. Generate a 6 digit validation token, we send this token to the user over their email & mobile number (controlled using configuration).
         // 4. Save this validation token in new fields on the user record. 
-        const { token, expiresAt } = this.otp();
+        const { token, expiresAt } = this.generateForgotPasswordToken();
         user.verificationTokenOnForgotPassword = token;
         user.verificationTokenOnForgotPasswordExpiresAt = expiresAt;
         await this.userRepository.save(user);
@@ -789,7 +811,7 @@ export class AuthenticationService {
                     firstName: user.username,
                     fullName: user.fullName,
                     // TODO: Need to prefix this with the page url where the forgot password page will open up.
-                    passwordResetLink: `${process.env.IAM_FRONTEND_APP_FORGOT_PASSWORD_PAGE_URL}?token=${user.verificationTokenOnForgotPassword}&username=${user.username}`,
+                    passwordResetLink: `${process.env.IAM_FRONTEND_APP_FORGOT_PASSWORD_PAGE_URL}?token=${user.verificationTokenOnForgotPassword}`,
                     companyLogoUrl: companyLogo
                 },
                 this.commonConfiguration.shouldQueueEmails,
@@ -816,63 +838,166 @@ export class AuthenticationService {
     }
 
     async confirmForgotPassword(confirmForgotPasswordDto: ConfirmForgotPasswordDto) {
-        // Steps / Algorithm: 
-        // 1. Identify the user using the specified "username", if not found exit.
-        // const user = await this.userRepository.findOne({
-        //     where: { username: confirmForgotPasswordDto.username, }
-        // });
-        const user = await this.resolveUser(confirmForgotPasswordDto.username, confirmForgotPasswordDto.email);
+        return this.dataSource.transaction(async (m) => {
+            // Resolve the user id first (by username/email), but DON'T check the token in JS.
+            const user = await this.resolveUserByVerificationToken(confirmForgotPasswordDto.verificationToken);
+            if (!user) throw new NotFoundException(ERROR_MESSAGES.INVALID_CREDENTIALS);
+            if (user.lastLoginProvider !== 'local') throw new BadRequestException(ERROR_MESSAGES.INVALID_CREDENTIALS);
+            if (!user.active) throw new UnauthorizedException(ERROR_MESSAGES.INVALID_CREDENTIALS);
+
+            // 1) Atomically consume the token (only one request can succeed)
+            const { affected } = await m
+                .createQueryBuilder()
+                .update(User)
+                .set({
+                    forgotPasswordConfirmedAt: () => 'NOW()',
+                    verificationTokenOnForgotPassword: () => 'NULL',
+                    verificationTokenOnForgotPasswordExpiresAt: () => 'NULL',
+                })
+                .where('id = :id', { id: user.id })
+                .andWhere('verificationTokenOnForgotPassword = :token', { token: confirmForgotPasswordDto.verificationToken })
+                .andWhere('verificationTokenOnForgotPasswordExpiresAt > NOW()')
+                .execute();
+
+            if (affected !== 1) {
+                // Token invalid/expired/already used (or a parallel call already consumed it)
+                throw new UnauthorizedException(ERROR_MESSAGES.INVALID_CREDENTIALS);
+            }
 
-        if (!user) {
-            throw new NotFoundException(ERROR_MESSAGES.USER_NOT_FOUND);
-        }
+            // 2) Now update the password & history (still inside the same transaction)
+            const pwdHash = await this.hashingService.hash(confirmForgotPasswordDto.password);
 
-        // 2. Validate if user has used a provider which is "local", only then it makes sense for us to initiate the forgot password routine. 
-        if (user.lastLoginProvider !== 'local') {
-            throw new BadRequestException(ERROR_MESSAGES.NON_LOCAL_PROVIDER);
-        }
-        if (!user.active) {
-            throw new UnauthorizedException(ERROR_MESSAGES.USER_INACTIVE);
-        }
+            // Avoid ever assigning plaintext:
+            // user.password = dto.password <-- remove this line in your original code
 
-        // 3. Validate the verification token is proper & update the user record. 
-        if (user.verificationTokenOnForgotPassword !== confirmForgotPasswordDto.verificationToken) {
-            throw new UnauthorizedException(ERROR_MESSAGES.INVALID_VERIFICATION_TOKEN);
-        }
-        if (user.verificationTokenOnForgotPasswordExpiresAt < new Date()) {
-            throw new UnauthorizedException(ERROR_MESSAGES.INVALID_VERIFICATION_TOKEN);
-        }
-        user.forgotPasswordConfirmedAt = new Date();
-        user.verificationTokenOnForgotPassword = null;
-        user.verificationTokenOnForgotPasswordExpiresAt = null;
+            // Check reuse with your existing method (ensure it looks at hashes).
+            const tempUser = { ...user, password: pwdHash } as User; // if your helper expects it
+            if (await this.isPasswordDuplicate(tempUser)) {
+                throw new BadRequestException(ERROR_MESSAGES.PASSWORD_REUSED);
+            }
 
-        // 4. Update the users password while encrypting it.
-        const pwd = await this.hashingService.hash(confirmForgotPasswordDto.password);
-        user.password = confirmForgotPasswordDto.password
+            await this.deleteOldPasswords(user);
 
-        if (await this.isPasswordDuplicate(user)) {
-            throw new BadRequestException(ERROR_MESSAGES.PASSWORD_REUSED);
-        }
-        await this.deleteOldPasswords(user);
+            await m.getRepository(User).update({ id: user.id }, { password: pwdHash });
 
-        user.password = pwd;
-        const userPasswordHistory = new UserPasswordHistory();
-        userPasswordHistory.passwordHash = pwd;
-        userPasswordHistory.user = user;
+            const history = m.getRepository(UserPasswordHistory).create({
+                user: { id: user.id } as any,
+                passwordHash: pwdHash,
+            });
+            await m.getRepository(UserPasswordHistory).save(history);
+            this.notifyUserOnPasswordChanged(user);
 
-        await this.userRepository.save(user);
-        //FIXME: Do this check conditionally, basis a configuration parameter i.e if IAM_ALLOW_PREVIOUS_PASSWORDS=false, default true
-        await this.userPasswordHistoryRepository.save(userPasswordHistory);
+            return {
+                status: 'success',
+                message: SUCCESS_MESSAGES.FORGOT_PASSWORD_CONFIRMED,
+                error: '',
+                errorCode: '',
+                data: {},
+            };
+        });
+    }
 
-        return {
-            status: 'success',
-            message: SUCCESS_MESSAGES.FORGOT_PASSWORD_CONFIRMED,
-            error: '',
-            errorCode: '',
-            data: {}
+    private async notifyUserOnPasswordChanged(user: User) {
+        const companyLogo = await this.getCompanyLogo();
+
+        const forgotPasswordSendVerificationTokenOn = this.iamConfiguration.forgotPasswordSendVerificationTokenOn;
+
+        if (forgotPasswordSendVerificationTokenOn == ForgotPasswordSendVerificationTokenOn.EMAIL) {
+            const mailService = this.mailServiceFactory.getMailService();
+            mailService.sendEmailUsingTemplate(
+                user.email,
+                'password-changed',
+                {
+                    solidAppName: process.env.SOLID_APP_NAME,
+                    solidAppWebsiteUrl: process.env.SOLID_APP_WEBSITE_URL,
+                    email: user.email,
+                    firstName: user.username,
+                    fullName: user.fullName,
+                    // TODO: Need to prefix this with the page url where the forgot password page will open up.
+                    passwordResetLink: `${process.env.IAM_FRONTEND_APP_FORGOT_PASSWORD_PAGE_URL}?token=${user.verificationTokenOnForgotPassword}`,
+                    companyLogoUrl: companyLogo
+                },
+                this.commonConfiguration.shouldQueueEmails,
+                null,
+                null,
+                'user',
+                user.id
+            );
+        }
+        // Assuming all users do not have mobile as mandatory.
+        if (forgotPasswordSendVerificationTokenOn == ForgotPasswordSendVerificationTokenOn.MOBILE && user.mobile) {
+            this.smsService.sendSMSUsingTemplate(
+                user.mobile,
+                'forgot-password',
+                {
+                    solidAppName: process.env.SOLID_APP_NAME,
+                    otp: user.verificationTokenOnForgotPassword,
+                    verificationTokenOnForgotPassword: user.verificationTokenOnForgotPassword,
+                    firstName: user.username,
+                    companyLogoUrl: companyLogo
+                }
+            );
         }
     }
 
+    // async confirmForgotPassword(confirmForgotPasswordDto: ConfirmForgotPasswordDto) {
+    //     // Steps / Algorithm: 
+    //     // 1. Identify the user using the specified "username", if not found exit.
+    //     // const user = await this.userRepository.findOne({
+    //     //     where: { username: confirmForgotPasswordDto.username, }
+    //     // });
+    //     const user = await this.resolveUserByVerificationToken(confirmForgotPasswordDto.verificationToken);
+
+    //     if (!user) {
+    //         throw new NotFoundException(ERROR_MESSAGES.USER_NOT_FOUND);
+    //     }
+
+    //     // 2. Validate if user has used a provider which is "local", only then it makes sense for us to initiate the forgot password routine. 
+    //     if (user.lastLoginProvider !== 'local') {
+    //         throw new BadRequestException(ERROR_MESSAGES.NON_LOCAL_PROVIDER);
+    //     }
+    //     if (!user.active) {
+    //         throw new UnauthorizedException(ERROR_MESSAGES.USER_INACTIVE);
+    //     }
+
+    //     // 3. Validate the verification token is proper & update the user record. 
+    //     if (user.verificationTokenOnForgotPassword !== confirmForgotPasswordDto.verificationToken) {
+    //         throw new UnauthorizedException(ERROR_MESSAGES.INVALID_VERIFICATION_TOKEN);
+    //     }
+    //     if (user.verificationTokenOnForgotPasswordExpiresAt < new Date()) {
+    //         throw new UnauthorizedException(ERROR_MESSAGES.INVALID_VERIFICATION_TOKEN);
+    //     }
+    //     user.forgotPasswordConfirmedAt = new Date();
+    //     user.verificationTokenOnForgotPassword = null;
+    //     user.verificationTokenOnForgotPasswordExpiresAt = null;
+
+    //     // 4. Update the users password while encrypting it.
+    //     const pwd = await this.hashingService.hash(confirmForgotPasswordDto.password);
+    //     user.password = confirmForgotPasswordDto.password
+
+    //     if (await this.isPasswordDuplicate(user)) {
+    //         throw new BadRequestException(ERROR_MESSAGES.PASSWORD_REUSED);
+    //     }
+    //     await this.deleteOldPasswords(user);
+
+    //     user.password = pwd;
+    //     const userPasswordHistory = new UserPasswordHistory();
+    //     userPasswordHistory.passwordHash = pwd;
+    //     userPasswordHistory.user = user;
+
+    //     await this.userRepository.save(user);
+    //     //FIXME: Do this check conditionally, basis a configuration parameter i.e if IAM_ALLOW_PREVIOUS_PASSWORDS=false, default true
+    //     await this.userPasswordHistoryRepository.save(userPasswordHistory);
+
+    //     return {
+    //         status: 'success',
+    //         message: SUCCESS_MESSAGES.FORGOT_PASSWORD_CONFIRMED,
+    //         error: '',
+    //         errorCode: '',
+    //         data: {}
+    //     }
+    // }
+
     //FIXME: Do this check conditionally, basis a configuration parameter i.e if IAM_ALLOW_PREVIOUS_PASSWORDS=true, return immediately without processing, i.e false.
     private async isPasswordDuplicate(user: User) {
         const userPwdHistoryEntityArray = await this.userPasswordHistoryRepository.findBy(
@@ -1088,7 +1213,7 @@ export class AuthenticationService {
             await this.userActivityHistoryService.logEvent('logout', user);
 
 
-            return { message: SUCCESS_MESSAGES.LOGOUT_SUCCESS};
+            return { message: SUCCESS_MESSAGES.LOGOUT_SUCCESS };
         } catch (err) {
             throw err instanceof UnauthorizedException || err instanceof InternalServerErrorException
                 ? err

package/src/services/chatter-message-details.service.ts

@@ -11,6 +11,7 @@ import { FileService } from 'src/services/file.service';
 import { CrudHelperService } from 'src/services/crud-helper.service';
 
 import { ChatterMessageDetails } from '../entities/chatter-message-details.entity';
+import { ChatterMessageDetailsRepository } from 'src/repository/chatter-message-details.repository';
 
 @Injectable()
 export class ChatterMessageDetailsService extends CRUDService<ChatterMessageDetails>{
@@ -23,8 +24,8 @@ export class ChatterMessageDetailsService extends CRUDService<ChatterMessageDeta
     readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
-    @InjectRepository(ChatterMessageDetails, 'default')
-    readonly repo: Repository<ChatterMessageDetails>,
+    // @InjectRepository(ChatterMessageDetails, 'default')
+    readonly repo: ChatterMessageDetailsRepository,
     readonly moduleRef: ModuleRef,
   ) {
     super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'chatterMessageDetails', 'solid-core', moduleRef);

package/src/services/chatter-message.service.ts

@@ -17,6 +17,7 @@ import { MediaStorageProviderType } from '../dtos/create-media-storage-provider-
 import { ChatterMessageDetails } from '../entities/chatter-message-details.entity';
 import { ModelMetadata } from 'src/entities/model-metadata.entity';
 import { RequestContextService } from './request-context.service';
+import { ChatterMessageRepository } from 'src/repository/chatter-message.repository';
 @Injectable()
 export class ChatterMessageService extends CRUDService<ChatterMessage>{
   constructor(
@@ -28,8 +29,8 @@ export class ChatterMessageService extends CRUDService<ChatterMessage>{
     readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
-    @InjectRepository(ChatterMessage, 'default')
-    readonly repo: Repository<ChatterMessage>,
+    // @InjectRepository(ChatterMessage, 'default')
+    readonly repo: ChatterMessageRepository,
     @InjectRepository(ChatterMessageDetails, 'default')
     readonly chatterMessageDetailsRepo: Repository<ChatterMessageDetails>,
     readonly moduleRef: ModuleRef,

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

@@ -5,15 +5,17 @@ import { CommonEntity } from 'src/entities/common.entity';
 import { ComputedFieldMetadata } from 'src/helpers/solid-registry';
 import { IEntityPreComputeFieldProvider } from 'src/interfaces';
 import { EntityManager } from 'typeorm';
-
+import { get } from "lodash";
 export interface AlphaNumExternalIdContext {
-  prefix: string; // The prefix to use for the external ID
-  length?: number; // Optional: length of the unique code to generate, default is 5
+  prefix?: string;              // alias -> staticPrefix
+  length?: number;              // Optional: length of the unique code to generate, default is 5
+  dynamicFieldPrefix?: string;  // NEW: field name on the entity
 }
 
 @ComputedFieldProvider()
 @Injectable()
-export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> implements IEntityPreComputeFieldProvider<T, AlphaNumExternalIdContext> {
+export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> implements IEntityPreComputeFieldProvider<T, AlphaNumExternalIdContext>
+{
   constructor(
     @InjectEntityManager()
     private readonly entityManager: EntityManager
@@ -24,14 +26,28 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
   }
 
   help(): string {
-    return 'Provider used to compute external ID for a CommonEntity.';
+    return 'Provider used to compute external ID for a CommonEntity with support for static or dynamic prefix.';
   }
 
-  async preComputeValue(triggerEntity: T, computedFieldMetadata: ComputedFieldMetadata<AlphaNumExternalIdContext>) {
-    const prefix = computedFieldMetadata.computedFieldValueProviderCtxt.prefix;
-    const codeLength = computedFieldMetadata.computedFieldValueProviderCtxt.length || 5;
-    const uniqueCode = await this.generateUniqueExternalId(codeLength, triggerEntity, computedFieldMetadata.fieldName);
-    triggerEntity[computedFieldMetadata.fieldName] = `${prefix}-${uniqueCode}`;
+  async preComputeValue( triggerEntity: T, computedFieldMetadata: ComputedFieldMetadata<AlphaNumExternalIdContext>
+ ) {
+    const { prefix, length, dynamicFieldPrefix } =
+      computedFieldMetadata.computedFieldValueProviderCtxt;
+
+    const codeLength = length || 5;
+
+    // Determine prefix
+    let resolvedPrefix = prefix || '';
+
+    if (dynamicFieldPrefix) {
+      const dynamicValue = get(triggerEntity as any, dynamicFieldPrefix);
+      if (dynamicValue) {
+        resolvedPrefix = String(dynamicValue).trim().toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9\-]/g, '');
+      }
+    }
+
+    const uniqueCode = await this.generateUniqueExternalId( codeLength, triggerEntity, computedFieldMetadata.fieldName );
+    triggerEntity[computedFieldMetadata.fieldName] = resolvedPrefix ? `${resolvedPrefix}-${uniqueCode}` : uniqueCode;
   }
 
   private generateRandomCode(length = 5): string {
@@ -43,10 +59,12 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
     return result;
   }
 
-  private async isExternalIdUnique(externalId: string, triggerEntity: T, fieldName: string): Promise<boolean> {
-    const count = await this.entityManager.count(triggerEntity.constructor.name, {
-      where: { [fieldName]: externalId },
-    });
+  private async isExternalIdUnique( externalId: string, triggerEntity: T, fieldName: string ): Promise<boolean> {
+    const count = await this.entityManager.count(triggerEntity.constructor as any,
+      {
+        where: { [fieldName]: externalId },
+      }
+    );
     return count === 0;
   }
 
@@ -56,7 +74,7 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
       const newId = this.generateRandomCode(codeLength);
 
-      const isUnique = await this.isExternalIdUnique(newId, triggerEntity, fieldName);
+      const isUnique = await this.isExternalIdUnique(newId,triggerEntity,fieldName);
 
       if (isUnique) {
         return newId;
@@ -65,4 +83,4 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
 
     throw new Error('Failed to generate a unique external ID after multiple attempts');
   }
-}
+}

package/src/services/crud.service.ts

@@ -1,4 +1,4 @@
-import { BadRequestException, Inject, Optional } from "@nestjs/common";
+import { BadRequestException, Inject, NotFoundException, Optional } from "@nestjs/common";
 import { ConfigService, ConfigType } from "@nestjs/config";
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { EntityManager, In, IsNull, Not, QueryFailedError, SelectQueryBuilder } from "typeorm";
@@ -37,6 +37,7 @@ import { ModuleMetadataService } from "./module-metadata.service";
 import { isArray } from "class-validator";
 import { ERROR_MESSAGES } from "src/constants/error-messages";
 import { SUCCESS_MESSAGES } from "src/constants/success-messages";
+import { RequestContextService } from "./request-context.service";
 
 export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDto, so we get the proper types in our service
 
@@ -437,6 +438,10 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
             }
         }
 
+        // Set the request filter in the request context service
+        const requestContextService = this.moduleRef.get(RequestContextService, { strict: false });
+        requestContextService.setRequestFilter(basicFilterDto);
+
         // Create above query on pincode table using query builder
         var qb: SelectQueryBuilder<T> = this.repo.createQueryBuilder(alias)
         qb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
@@ -639,7 +644,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
             select: fields,
         });
         if (!entity) {
-            throw new Error(`Entity [${this.moduleName}.${this.modelName}] with id ${id} not found`);
+            throw new NotFoundException(`Entity [${this.moduleName}.${this.modelName}] with id ${id} not found`);
         }
         // Populate the entity with the media
         if (normalizedPopulateMedia.length > 0) {

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

@@ -660,9 +660,23 @@ export class ModelMetadataService {
     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 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);
 
@@ -1034,7 +1048,7 @@ export class ModelMetadataService {
       type: "solid",
       domain: "" as any,
       context: "" as any,
-      customComponent: `/admin/address-master/${model.singularName}/all`,
+      customComponent: "",
       customIsModal: true,
       serverEndpoint: "",
       view: view,

package/src/services/request-context.service.ts

@@ -1,6 +1,7 @@
 import { Injectable } from "@nestjs/common";
 import { ClsService } from "nestjs-cls";
 import { REQUEST_USER_KEY } from "src/constants";
+import { BasicFilterDto } from "src/dtos/basic-filters.dto";
 
 @Injectable()
 export class RequestContextService {
@@ -20,4 +21,12 @@ export class RequestContextService {
         return this.cls.get('userAgent');
     }
 
+    setRequestFilter(filter: BasicFilterDto) {
+        this.cls.set('filter', filter);
+    }
+
+    getRequestFilter(): BasicFilterDto | undefined {
+        return this.cls.get('filter');
+    }
+
 }

package/src/solid-core.module.ts

@@ -270,6 +270,9 @@ import { MailFactory } from './factories/mail.factory';
 import { TwilioSMSService } from './services/sms/TwilioSMSService';
 import { PollerService } from './services/poller.service';
 import { TextractService } from './services/textract.service';
+import { seconds, ThrottlerModule } from '@nestjs/throttler';
+import { ChatterMessageRepository } from './repository/chatter-message.repository';
+import { ChatterMessageDetailsRepository } from './repository/chatter-message-details.repository';
 
 
 @Global()
@@ -309,6 +312,10 @@ import { TextractService } from './services/textract.service';
       ImportTransactionErrorLog,
       UserActivityHistory,
       AiInteraction,
+      Dashboard,
+      DashboardVariable,
+      DashboardQuestion,
+      DashboardQuestionSqlDatasetConfig,
     ]),
     ConfigModule.forFeature(appBuilderConfig),
     ConfigModule.forFeature(commonConfig),
@@ -319,6 +326,17 @@ import { TextractService } from './services/textract.service';
     ServeStaticModule.forRoot({
       rootPath: join(process.cwd(), 'media-files-storage'),
       serveRoot: '/media-files-storage',
+      serveStaticOptions: {
+        setHeaders: (res /*, path, stat*/) => {
+          // Allow use of these files from a different origin (e.g., :3000 UI)
+          // Use 'same-site' if both origins are on the same site (localhost:* counts as same-site)
+          res.setHeader('Cross-Origin-Resource-Policy', 'cross-origin'); // or 'same-site'
+
+          // If you need to load into <canvas> without tainting or fetch images via XHR,
+          // you can also expose CORS here (not needed for simple <img>):
+          // res.setHeader('Access-Control-Allow-Origin', 'http://localhost:3000');
+        },
+      }
     }),
     MulterModule.registerAsync({
       imports: [ConfigModule],
@@ -330,11 +348,14 @@ import { TextractService } from './services/textract.service';
     HttpModule,
     ConfigModule,
     ClsModule,
-    TypeOrmModule.forFeature([Dashboard]),
-    TypeOrmModule.forFeature([DashboardVariable]),
-    TypeOrmModule.forFeature([DashboardQuestion]),
-    TypeOrmModule.forFeature([DashboardQuestionSqlDatasetConfig]),
-    TypeOrmModule.forFeature([AiInteraction]),
+    ThrottlerModule.forRoot({
+      throttlers: [
+        { name: 'short', ttl: seconds(10),  limit: 10 },
+        { name: 'login', ttl: seconds(10),  limit: 5  },
+        { name: 'burst', ttl: seconds(1),  limit: 100 },
+        { name: 'sustained', ttl: seconds(300), limit: 500 },
+      ],
+    }),
   ],
   controllers: [
     ModuleMetadataController,
@@ -567,6 +588,8 @@ import { TextractService } from './services/textract.service';
     ScheduledJobSubscriber,
     AlphaNumExternalIdComputationProvider,
     MailFactory,
+    ChatterMessageRepository,
+    ChatterMessageDetailsRepository,
   ],
   exports: [
     ModuleMetadataService,
@@ -613,6 +636,7 @@ import { TextractService } from './services/textract.service';
     MailFactory,
     PollerService,
     AiInteractionService,
+    ThrottlerModule,
   ],
 })
 export class SolidCoreModule { }