@solidstarters/solid-core 1.2.200 → 1.2.202

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

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
@@ -7,7 +7,7 @@ import { CRUDService } from 'src/services/crud.service';
 import { FileService } from "src/services/file.service";
 import { ModelMetadataService } from 'src/services/model-metadata.service';
 import { ModuleMetadataService } from 'src/services/module-metadata.service';
-import { EntityManager } from 'typeorm';
+import { EntityManager, In } from 'typeorm';
 
 
 import { ActionMetadataRepository } from 'src/repository/action-metadata.repository';
@@ -16,6 +16,7 @@ import { ActionMetadata } from '../entities/action-metadata.entity';
 @Injectable()
 export class ActionMetadataService extends CRUDService<ActionMetadata> {
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,

package/src/services/ai-interaction.service.ts

@@ -1,4 +1,4 @@
-import { BadRequestException, Injectable, Logger } from '@nestjs/common';
+import { BadRequestException, forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
 import { EntityManager } from 'typeorm';
@@ -24,6 +24,7 @@ export class AiInteractionService extends CRUDService<AiInteraction> {
   private readonly logger = new Logger(AiInteractionService.name);
 
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,

package/src/services/authentication.service.ts

@@ -49,6 +49,7 @@ import { RoleMetadataService } from './role-metadata.service';
 import { SettingService } from './setting.service';
 import { UserActivityHistoryService } from './user-activity-history.service';
 import { UserService } from './user.service';
+import { SmsFactory } from 'src/factories/sms.factory';
 
 enum LoginProvider {
     LOCAL = 'local',
@@ -79,7 +80,8 @@ export class AuthenticationService {
         private readonly httpService: HttpService,
         // private readonly mailService: SMTPEMailService,
         private readonly mailServiceFactory: MailFactory,
-        private readonly smsService: Msg91OTPService,
+        // private readonly smsService: Msg91OTPService,
+        private readonly smsFactory: SmsFactory,
         private readonly eventEmitter: EventEmitter2,
         private readonly settingService: SettingService,
         private readonly roleMetadataService: RoleMetadataService,
@@ -197,7 +199,7 @@ export class AuthenticationService {
             // Merge the extended signUpDto attributes into the user entity 
             //@ts-ignore 
             const extensionUser = extensionUserRepo.merge(extensionUserRepo.create() as T, extensionUserDto);
-            var { user, pwd, autoGeneratedPwd } = await this.populateForSignup<T>(extensionUser, signUpDto, true, onForcePasswordChange);
+            var { user, pwd, autoGeneratedPwd } = await this.populateForSignup<T>(extensionUser, signUpDto, extensionUserDto.active ?? true, onForcePasswordChange);
             const savedUser = await extensionUserRepo.save(user);
 
             await this.handlePostSignup(savedUser, signUpDto.roles, pwd, autoGeneratedPwd);
@@ -278,6 +280,9 @@ export class AuthenticationService {
         if (user.forcePasswordChange && autoGeneratedPwd) {
             this.notifyUserOnForcePasswordChange(user, autoGeneratedPwd);
         }
+
+        // Send welcome notifications (email/SMS) if enabled.
+        await this.notifyUserOnSignup(user);
     }
 
 
@@ -323,6 +328,56 @@ export class AuthenticationService {
 
     }
 
+    private isWelcomeEmailEnabled(): boolean {
+        return this.iamConfiguration.sendWelcomeEmailOnSignup;
+    }
+
+    private isWelcomeSmsEnabled(): boolean {
+        return this.iamConfiguration.sendWelcomeSmsOnSignup;
+    }
+
+    private async notifyUserOnSignup(user: User) {
+        const companyLogo = await this.getCompanyLogo();
+        // Email welcome
+        if (this.isWelcomeEmailEnabled()) {
+            const mailService = this.mailServiceFactory.getMailService();
+            mailService.sendEmailUsingTemplate(
+                user.email,
+                'email-on-signup',
+                {
+                    solidAppName: process.env.SOLID_APP_NAME,
+                    solidAppWebsiteUrl: process.env.SOLID_APP_WEBSITE_URL,
+                    frontendLoginPageUrl: process.env.IAM_FRONTEND_APP_LOGIN_PAGE_URL,
+                    email: user.email,
+                    fullName: user.fullName,
+                    userName: user.username,
+                    companyLogoUrl: companyLogo
+                },
+                this.commonConfiguration.shouldQueueEmails,
+                null,
+                null,
+                'user',
+                user.id
+            );
+        }
+
+        // SMS welcome
+        if (this.isWelcomeSmsEnabled() && user.mobile) {
+            const smsService = this.smsFactory.getSmsService();
+            smsService.sendSMSUsingTemplate(
+                user.mobile,
+                'text-on-signup',
+                {
+                    solidAppName: process.env.SOLID_APP_NAME,
+                    frontendLoginPageUrl: process.env.IAM_FRONTEND_APP_LOGIN_PAGE_URL,
+                    firstName: user.username,
+                    fullName: user.fullName ? user.fullName : user.username
+                },
+                this.commonConfiguration.shouldQueueSms,
+            );
+        }
+    }
+
     async otpInitiateRegistration(signUpDto: OTPSignUpDto) {
         try {
             if (!this.isPasswordlessRegistrationEnabled()) {
@@ -444,7 +499,8 @@ export class AuthenticationService {
             );
         }
         if (registrationValidationSources.includes(RegistrationValidationSource.MOBILE)) {
-            this.smsService.sendSMSUsingTemplate(
+            const smsService = this.smsFactory.getSmsService();
+            smsService.sendSMSUsingTemplate(
                 user.mobile,
                 'otp-on-register',
                 {
@@ -454,7 +510,8 @@ export class AuthenticationService {
                     firstName: user.username,
                     fullName: user.fullName ? user.fullName : user.username,
                     companyLogoUrl: companyLogo
-                }
+                },
+                this.commonConfiguration.shouldQueueSms,
             );
         }
     }
@@ -571,11 +628,18 @@ export class AuthenticationService {
 
         // Validate & generate otp token for the user based on the identifier type.
         if (signInDto.type === RegistrationValidationSource.EMAIL) {
+            // const user = await this.userRepository.findOne({
+            //     where: {
+            //         email: signInDto.identifier,
+            //     }
+            // });
             const user = await this.userRepository.findOne({
-                where: {
-                    email: signInDto.identifier,
-                }
+                where: [
+                    { username: signInDto.identifier },
+                    { email: signInDto.identifier },
+                ]
             });
+
             if (!user) {
                 throw new UnauthorizedException(ERROR_MESSAGES.USER_NOT_FOUND);
             }
@@ -588,11 +652,18 @@ export class AuthenticationService {
             await this.userRepository.save(user);
             this.notifyUserOnOtpInititateLogin(user, RegistrationValidationSource.EMAIL);
         } else if (signInDto.type === RegistrationValidationSource.MOBILE) {
+            // const user = await this.userRepository.findOne({
+            //     where: {
+            //         mobile: signInDto.identifier,
+            //     }
+            // });
             const user = await this.userRepository.findOne({
-                where: {
-                    mobile: signInDto.identifier,
-                }
+                where: [
+                    { username: signInDto.identifier },
+                    { mobile: signInDto.identifier },
+                ]
             });
+
             if (!user) {
                 throw new UnauthorizedException(ERROR_MESSAGES.USER_NOT_FOUND);
             }
@@ -635,7 +706,8 @@ export class AuthenticationService {
             );
         }
         if (loginType === RegistrationValidationSource.MOBILE) {
-            this.smsService.sendSMSUsingTemplate(
+            const smsService = this.smsFactory.getSmsService();
+            smsService.sendSMSUsingTemplate(
                 user.mobile,
                 'otp-on-login',
                 {
@@ -645,7 +717,8 @@ export class AuthenticationService {
                     firstName: user.username,
                     fullName: user.fullName ? user.fullName : user.username,
                     companyLogoUrl: companyLogo
-                }
+                },
+                this.commonConfiguration.shouldQueueSms,
             );
         }
     }
@@ -655,11 +728,20 @@ export class AuthenticationService {
             throw new BadRequestException(ERROR_MESSAGES.PASSWORDLESS_REGISTRATION_DISABLED);
         }
         if (confirmSignInDto.type === RegistrationValidationSource.EMAIL) {
+            // const user = await this.userRepository.findOne({
+            //     where: {
+            //         email: confirmSignInDto.identifier,
+            //     },
+            //     relations: ['roles']
+            // });
             const user = await this.userRepository.findOne({
-                where: {
-                    email: confirmSignInDto.identifier,
-                },
-                relations: ['roles']
+                where: [
+                    { username: confirmSignInDto.identifier },
+                    { email: confirmSignInDto.identifier },
+                ],
+                relations: {
+                    roles: true
+                }
             });
             if (!user) {
                 throw new UnauthorizedException(ERROR_MESSAGES.USER_NOT_FOUND);
@@ -682,11 +764,20 @@ export class AuthenticationService {
             const roles = user.roles.map((role) => role.name);
             return { accessToken, refreshToken, user: { id, username, email, mobile, lastLoginProvider, roles } };
         } else if (confirmSignInDto.type === RegistrationValidationSource.MOBILE) {
+            // const user = await this.userRepository.findOne({
+            //     where: {
+            //         mobile: confirmSignInDto.identifier,
+            //     },
+            //     relations: ['roles']
+            // });
             const user = await this.userRepository.findOne({
-                where: {
-                    mobile: confirmSignInDto.identifier,
-                },
-                relations: ['roles']
+                where: [
+                    { username: confirmSignInDto.identifier },
+                    { mobile: confirmSignInDto.identifier },
+                ],
+                relations: {
+                    roles: true
+                }
             });
             if (!user) {
                 throw new UnauthorizedException(ERROR_MESSAGES.USER_NOT_ACTIVE);
@@ -856,7 +947,8 @@ export class AuthenticationService {
         }
         // Assuming all users do not have mobile as mandatory.
         if (forgotPasswordSendVerificationTokenOn == ForgotPasswordSendVerificationTokenOn.MOBILE && user.mobile) {
-            this.smsService.sendSMSUsingTemplate(
+            const smsService = this.smsFactory.getSmsService();
+            smsService.sendSMSUsingTemplate(
                 user.mobile,
                 'forgot-password',
                 {
@@ -865,7 +957,8 @@ export class AuthenticationService {
                     verificationTokenOnForgotPassword: user.verificationTokenOnForgotPassword,
                     firstName: user.username,
                     companyLogoUrl: companyLogo
-                }
+                },
+                this.commonConfiguration.shouldQueueSms,
             );
         }
     }
@@ -945,7 +1038,8 @@ export class AuthenticationService {
         }
         // Assuming all users do not have mobile as mandatory.
         if (forgotPasswordSendVerificationTokenOn == ForgotPasswordSendVerificationTokenOn.MOBILE && user.mobile) {
-            this.smsService.sendSMSUsingTemplate(
+            const smsService = this.smsFactory.getSmsService();
+            smsService.sendSMSUsingTemplate(
                 user.mobile,
                 'forgot-password',
                 {
@@ -954,7 +1048,8 @@ export class AuthenticationService {
                     verificationTokenOnForgotPassword: user.verificationTokenOnForgotPassword,
                     firstName: user.username,
                     companyLogoUrl: companyLogo
-                }
+                },
+                this.commonConfiguration.shouldQueueSms,
             );
         }
     }

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

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
 import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
 import { DiscoveryService, ModuleRef  } from "@nestjs/core";
 import { EntityManager, Repository, In } from 'typeorm';
@@ -16,6 +16,7 @@ import { ChatterMessageDetailsRepository } from 'src/repository/chatter-message-
 @Injectable()
 export class ChatterMessageDetailsService extends CRUDService<ChatterMessageDetails>{
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,

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

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
 import { Brackets, EntityManager, EntityMetadata } from 'typeorm';
@@ -26,6 +26,7 @@ import { RequestContextService } from './request-context.service';
 @Injectable()
 export class ChatterMessageService extends CRUDService<ChatterMessage> {
     constructor(
+        @Inject(forwardRef(() => ModelMetadataService))
         readonly modelMetadataService: ModelMetadataService,
         readonly moduleMetadataService: ModuleMetadataService,
         readonly configService: ConfigService,
@@ -44,6 +45,7 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         readonly moduleRef: ModuleRef,
         // @InjectRepository(ModelMetadata)
         // private readonly modelMetadataRepo: Repository<ModelMetadata>,
+        @Inject(forwardRef(() => ModelMetadataRepository))
         private readonly modelMetadataRepo: ModelMetadataRepository,
         readonly requestContextService: RequestContextService,
         private readonly modelMetadataHelperService: ModelMetadataHelperService,
@@ -116,7 +118,7 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
 
         const auditFields = model.fields.filter(field =>
             field.enableAuditTracking &&
-            !['mediaSingle', 'mediaMultiple', 'computed', 'richText', 'json'].includes(field.type) &&
+            !['mediaSingle', 'mediaMultiple', 'richText', 'json'].includes(field.type) &&
             !(field.type === 'relation' && field.relationType === 'one-to-many')
         );
 
@@ -179,7 +181,7 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
 
         const auditFields = modelFields.filter(field =>
             field.enableAuditTracking &&
-            !['mediaSingle', 'mediaMultiple', 'computed', 'richText', 'json'].includes(field.type) &&
+            !['mediaSingle', 'mediaMultiple', 'richText', 'json'].includes(field.type) &&
             !(field.type === 'relation' && field.relationType === 'one-to-many')
         );
 
@@ -542,7 +544,11 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
             });
 
             if (coModel) {
-                const relatedEntityRepository = this.entityManager.getRepository(classify(coModelName));
+                //const relatedEntityRepository = this.entityManager.getRepository(classify(coModelName));
+                const dsName = coModel.dataSource || 'default';
+                const em = dsName === 'default' ? this.entityManager : this.moduleRef.get(`${dsName}EntityManager`, { strict: false });
+
+                const relatedEntityRepository = em.getRepository(classify(coModelName));
 
                 const relatedEntities = await relatedEntityRepository.find({
                     where: { [coModelFieldName]: { id: entityId } }

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

@@ -28,10 +28,10 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
     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, length, dynamicFieldPrefix } =
-      computedFieldMetadata.computedFieldValueProviderCtxt;
+  async preComputeValue(triggerEntity: T, computedFieldMetadata: ComputedFieldMetadata<AlphaNumExternalIdContext>) {
+    const { prefix, length, dynamicFieldPrefix } = computedFieldMetadata.computedFieldValueProviderCtxt;
+    const eventContext = computedFieldMetadata.eventContext;
+    const entityName = eventContext?.metadataName ?? eventContext.databaseEntity?.constructor?.name ?? '';
 
     const codeLength = length || 5;
 
@@ -45,7 +45,7 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
       }
     }
 
-    const uniqueCode = await this.generateUniqueExternalId(resolvedPrefix, codeLength, triggerEntity, computedFieldMetadata.fieldName);
+    const uniqueCode = await this.generateUniqueExternalId(resolvedPrefix, codeLength, computedFieldMetadata.fieldName, entityName);
     const finalExternalId = resolvedPrefix ? `${resolvedPrefix}-${uniqueCode}` : uniqueCode;
 
     triggerEntity[computedFieldMetadata.fieldName] = finalExternalId;
@@ -60,8 +60,8 @@ 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 as any,
+  private async isExternalIdUnique(externalId: string, fieldName: string, entityName: string): Promise<boolean> {
+    const count = await this.entityManager.count(entityName as any,
       {
         where: { [fieldName]: externalId },
       }
@@ -69,7 +69,7 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
     return count === 0;
   }
 
-  private async generateUniqueExternalId(resolvedPrefix: string, codeLength: number, triggerEntity: T, fieldName: string): Promise<string> {
+  private async generateUniqueExternalId(resolvedPrefix: string, codeLength: number, fieldName: string, entityName: string): Promise<string> {
     const maxAttempts = 10;
 
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
@@ -78,7 +78,7 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
 
       const fullId = resolvedPrefix ? `${resolvedPrefix}-${newId}` : newId;
 
-      const isUnique = await this.isExternalIdUnique(fullId, triggerEntity, fieldName);
+      const isUnique = await this.isExternalIdUnique(fullId, fieldName, entityName);
 
       if (isUnique) {
         return newId;

package/src/services/computed-fields/entity/sequence-num-computed-field-provider.ts

@@ -0,0 +1,86 @@
+import { Injectable } from "@nestjs/common";
+import { InjectDataSource } from "@nestjs/typeorm";
+import { ComputedFieldProvider } from "src/decorators/computed-field-provider.decorator";
+import { CommonEntity } from "src/entities/common.entity";
+import { ModelSequence } from "src/entities/model-sequence.entity";
+import { ComputedFieldMetadata } from "src/helpers/solid-registry";
+import { IEntityPreComputeFieldProvider } from "src/interfaces";
+import { DataSource, EntityTarget } from "typeorm";
+
+
+export interface SequenceNumComputedFieldContext {
+    sequenceName: string; // The separator to use between concatenated values
+}
+
+@ComputedFieldProvider()
+@Injectable()
+export class SequenceNumComputedFieldProvider<T extends CommonEntity> implements IEntityPreComputeFieldProvider<T, SequenceNumComputedFieldContext> {
+    constructor(
+        @InjectDataSource()
+        private readonly dataSource: DataSource
+    ) { }
+
+    name(): string {
+        return "SequenceNumComputedFieldProvider";
+    }
+
+    help(): string {
+        return "Computed field provider used to create fields whose value is based on some prefix, padding & sequence number.";
+    }
+
+    async preComputeValue(triggerEntity: T, computedFieldMetadata: ComputedFieldMetadata<SequenceNumComputedFieldContext>) {
+        const { sequenceName } =
+            computedFieldMetadata.computedFieldValueProviderCtxt ?? {};
+
+        if (!sequenceName) {
+            throw new Error("sequenceName is required for sequence computation");
+        }
+
+        await this.dataSource.transaction(async (manager) => {
+            /**
+             * 1️⃣ Lock sequence row (prevents race conditions)
+             */
+            // 1️⃣ Fetch sequence row
+            const modelSequenceRepo = manager.getRepository(ModelSequence)
+            const modelSequence = await modelSequenceRepo.findOne({
+                where: { sequenceName },
+                lock: { mode: "pessimistic_write" }
+            });
+
+            if (!modelSequence) {
+                throw new Error(`ModelSequence not found for ${sequenceName}`);
+            }
+
+            // 2️⃣ Generate next sequence value
+            const nextValue = modelSequence.currentValue + 1;
+
+            const paddedValue = String(nextValue).padStart(modelSequence.padding ?? 5, "0");
+
+            const prefix = modelSequence.prefix ?? "";
+            const separator = modelSequence.separator ?? "";
+
+            const sequenceString = `${prefix}${separator}${paddedValue}`;
+
+            // 3️⃣ Duplicate check on TARGET ENTITY (extra safety)
+            const entityRepo = manager.getRepository(triggerEntity.constructor as any);
+
+            const existing = await entityRepo.findOne({
+                where: {
+                    [computedFieldMetadata.fieldName]: sequenceString,
+                },
+            });
+
+            if (existing) {
+                throw new Error(`Duplicate Sequence generated: ${sequenceString}`);
+            }
+
+            // 4️⃣ set the computed field on the entity
+            (triggerEntity as any)[computedFieldMetadata.fieldName] = sequenceString;
+
+            // 5️⃣ Persist updated sequence current value
+            modelSequence.currentValue = nextValue;
+            await modelSequenceRepo.save(modelSequence);
+        });
+    }
+
+}