@solidxai/core 0.1.10-beta.2 → 0.1.10-beta.22

package/src/services/authentication.service.ts

@@ -50,6 +50,7 @@ import { SettingService } from "./setting.service";
 import { UserActivityHistoryService } from "./user-activity-history.service";
 import { UserService } from "./user.service";
 import { SmsFactory } from "src/factories/sms.factory";
+import { WhatsAppFactory } from "src/factories/whatsapp.factory";
 import { SolidRegistry } from "src/helpers/solid-registry";
 
 enum LoginProvider {
@@ -79,6 +80,7 @@ export class AuthenticationService {
     private readonly mailServiceFactory: MailFactory,
     // private readonly smsService: Msg91OTPService,
     private readonly smsFactory: SmsFactory,
+    private readonly whatsAppFactory: WhatsAppFactory,
     private readonly eventEmitter: EventEmitter2,
     private readonly settingService: SettingService,
     private readonly roleMetadataService: RoleMetadataService,
@@ -164,6 +166,8 @@ export class AuthenticationService {
     "mobile",
     "roles",
     "forcePasswordChange",
+    "isAllowedToGenerateApiKeys",
+    "failedLoginAttempts",
   ]);
 
   async signUp(
@@ -228,9 +232,11 @@ export class AuthenticationService {
         userRoles.push(defaultRole);
       }
       await this.handlePostSignup(savedUser, userRoles, pwd, autoGeneratedPwd);
+      await this.handlePasswordlessSignupOtp(savedUser, signUpDto, autoGeneratedPwd, repo);
+      this.triggerRegistrationEvent(savedUser);
 
       return savedUser;
-    } catch (err) {
+    } catch (err: any) {
       const pgUniqueViolationErrorCode = "23505";
       if (err.code === pgUniqueViolationErrorCode) {
         throw new ConflictException(
@@ -243,6 +249,42 @@ export class AuthenticationService {
     }
   }
 
+  private async handlePasswordlessSignupOtp<T extends User>(
+    user: T,
+    signUpDto: SignUpDto,
+    autoGeneratedPwd: string,
+    repo: Repository<T>,
+  ): Promise<void> {
+    const isPasswordProvided = !!signUpDto.password;
+    const isAutoGeneratedPassword = !!autoGeneratedPwd;
+    if (isPasswordProvided || isAutoGeneratedPassword) {
+      return;
+    }
+
+    if (!user.mobile) {
+      this.logger.warn(
+        `Skipping passwordless signup OTP WhatsApp notification for user ${user.username}: mobile is missing.`,
+      );
+      return;
+    }
+
+    const isPasswordlessRegistrationEnabled =
+      await this.isPasswordlessRegistrationEnabled();
+    if (!isPasswordlessRegistrationEnabled) {
+      return;
+    }
+
+    await this.assignRegistrationOtp(
+      PasswordlessRegistrationValidateWhatSources.MOBILE,
+      user,
+    );
+    await repo.save(user);
+    await this.notifyUserOnOtpInitiateRegistration(
+      user,
+      PasswordlessRegistrationValidateWhatSources.MOBILE,
+    );
+  }
+
   /** @deprecated Use IExtensionUserCreationProvider instead. Kept for backward compatibility. */
   async signupForExtensionUser<T extends User>(
     signUpDto: SignUpDto,
@@ -485,7 +527,7 @@ export class AuthenticationService {
         validationSource,
       );
       await this.notifyUserOnOtpInitiateRegistration(user, validationSource);
-    } catch (err) {
+    } catch (err: any) {
       if (err.code === "23505") {
         throw new ConflictException(ERROR_MESSAGES.USER_ALREADY_EXISTS);
       }
@@ -614,7 +656,7 @@ export class AuthenticationService {
     const companyLogo = await this.getCompanyLogo();
     if (
       registrationValidationSource ===
-      PasswordlessLoginValidateWhatSources.EMAIL
+      PasswordlessRegistrationValidateWhatSources.EMAIL
     ) {
       const mailService = this.mailServiceFactory.getMailService();
       mailService.sendEmailUsingTemplate(
@@ -644,25 +686,141 @@ export class AuthenticationService {
     }
     if (
       registrationValidationSource ===
-      PasswordlessLoginValidateWhatSources.MOBILE
+      PasswordlessRegistrationValidateWhatSources.MOBILE
     ) {
-      const smsService = this.smsFactory.getSmsService();
-      smsService.sendSMSUsingTemplate(
+      const templateParams = {
+        solidAppName:
+          this.settingService.getConfigValue<SolidCoreSetting>("appTitle"),
+        otp: user.mobileVerificationTokenOnRegistration,
+        mobileVerificationTokenOnRegistration:
+          user.mobileVerificationTokenOnRegistration,
+        firstName: user.username,
+        fullName: user.fullName ? user.fullName : user.username,
+        companyLogoUrl: companyLogo,
+      };
+
+      const whatsappDestination = this.normalizeWhatsAppDestination(
         user.mobile,
-        "otp-on-register",
-        {
-          solidAppName:
-            this.settingService.getConfigValue<SolidCoreSetting>("appTitle"),
-          otp: user.mobileVerificationTokenOnRegistration,
-          mobileVerificationTokenOnRegistration:
-            user.mobileVerificationTokenOnRegistration,
-          firstName: user.username,
-          fullName: user.fullName ? user.fullName : user.username,
-          companyLogoUrl: companyLogo,
-        },
-        this.settingService.getConfigValue<SolidCoreSetting>("shouldQueueSms"),
       );
+      const gupshupTemplateAppName =
+        process.env.COMMON_GUPSHUP_APP_NAME || "Gupshup";
+      const whatsappTemplateId =
+        this.settingService.getConfigValue<SolidCoreSetting>(
+          "otpWhatsappTemplateId",
+        ) || "common_otp";
+      const whatsappIndependentEnabled =
+        this.settingService.getConfigValue<SolidCoreSetting>(
+          "otpWhatsappIndependentEnabled",
+        ) !== false;
+
+      let smsSent = false;
+      let whatsappSent = false;
+      let smsErrorMessage: string | undefined;
+      let whatsappErrorMessage: string | undefined;
+
+      this.logger.debug(
+        `OTP SMS send attempt: destination=${user.mobile}, whatsappDestination=${whatsappDestination}`,
+      );
+
+      try {
+        const smsService = this.smsFactory.getSmsService();
+        await smsService.sendSMSUsingTemplate(
+          user.mobile,
+          "otp-on-register",
+          templateParams,
+          false,
+        );
+        smsSent = true;
+      } catch (smsError: any) {
+        smsErrorMessage = smsError?.message;
+        this.logger.warn(
+          `OTP SMS failed: destination=${user.mobile}, message=${smsErrorMessage}`,
+        );
+      }
+
+      if (whatsappIndependentEnabled) {
+        if (!whatsappDestination) {
+          whatsappErrorMessage = "Normalized WhatsApp destination is empty";
+          this.logger.error(
+            `Independent OTP WhatsApp skipped: destination=${user.mobile}, message=${whatsappErrorMessage}`,
+          );
+        } else {
+          this.logger.debug(
+            `Independent OTP WhatsApp send attempt: destination=${user.mobile}, whatsappDestination=${whatsappDestination}, templateId=${whatsappTemplateId}`,
+          );
+          try {
+            await this.sendOtpToWhatsappProvider(
+              whatsappDestination,
+              String(whatsappTemplateId),
+              String(gupshupTemplateAppName),
+              String(templateParams.otp || ""),
+            );
+            whatsappSent = true;
+            this.logger.log(
+              `Independent OTP WhatsApp success: destination=${user.mobile}, whatsappDestination=${whatsappDestination}, templateId=${whatsappTemplateId}`,
+            );
+          } catch (waError: any) {
+            whatsappErrorMessage = waError?.message;
+            this.logger.error(
+              `Independent OTP WhatsApp failed: destination=${user.mobile}, whatsappDestination=${whatsappDestination}, templateId=${whatsappTemplateId}, message=${whatsappErrorMessage}`,
+            );
+          }
+        }
+      }
+
+      if (!smsSent && !whatsappSent) {
+        throw new Error(
+          `OTP delivery failed on both channels. smsError=${smsErrorMessage || "unknown"}, whatsappError=${whatsappErrorMessage || "disabled/unknown"}`,
+        );
+      }
+    }
+  }
+
+  private normalizeWhatsAppDestination(rawMobile: string): string {
+    const raw = (rawMobile || "").trim();
+    let sanitized = raw.replace(/[^\d+]/g, "");
+
+    if (sanitized.startsWith("00")) {
+      sanitized = `+${sanitized.slice(2)}`;
+    }
+
+    const defaultDialCode = String(
+      this.settingService.getConfigValue<SolidCoreSetting>(
+        "otpDefaultCountryDialCode",
+      ) || "",
+    ).replace(/\D/g, "");
+
+    if (sanitized.startsWith("+")) {
+      const e164Digits = sanitized.slice(1).replace(/\D/g, "");
+      if (e164Digits.length >= 8 && e164Digits.length <= 15) {
+        return e164Digits;
+      }
     }
+
+    const digits = sanitized.replace(/\D/g, "");
+
+    if (digits.length >= 11 && digits.length <= 15) {
+      return digits;
+    }
+
+    if (digits.length === 10 && defaultDialCode) {
+      return `${defaultDialCode}${digits}`;
+    }
+
+    return digits;
+  }
+
+  private async sendOtpToWhatsappProvider(
+    destination: string,
+    templateId: string,
+    appName: string,
+    otp: string,
+  ): Promise<void> {
+    const whatsappService = this.whatsAppFactory.getWhatsappService();
+    await whatsappService.sendWhatsAppMessage(destination, null, {
+      type: "text",
+      text: `${appName} OTP is ${otp}. It is valid for 10 mins.`,
+    });
   }
 
   async otpConfirmRegistration(confirmSignUpDto: OTPConfirmOTPDto) {
@@ -765,7 +923,7 @@ export class AuthenticationService {
       this.resolvePasswordlessValidationSource();
     if (
       registrationValidationSource ===
-      PasswordlessLoginValidateWhatSources.EMAIL
+      PasswordlessRegistrationValidateWhatSources.EMAIL
     ) {
       if (!user.emailVerifiedOnRegistrationAt) {
         return false;
@@ -773,7 +931,7 @@ export class AuthenticationService {
     }
     if (
       registrationValidationSource ===
-      PasswordlessLoginValidateWhatSources.MOBILE
+      PasswordlessRegistrationValidateWhatSources.MOBILE
     ) {
       if (!user.mobileVerifiedOnRegistrationAt) {
         return false;
@@ -888,7 +1046,7 @@ export class AuthenticationService {
     const dummyOtp = this.getDummyOtpForUser(user);
     if (!dummyOtp) {
       await this.assignLoginOtp(user, type);
-      this.notifyUserOnOtpInititateLogin(user, type);
+      await this.notifyUserOnOtpInititateLogin(user, type);
     }
     return this.buildLoginOtpResponse(user, type);
   }
@@ -1013,21 +1171,88 @@ export class AuthenticationService {
       );
     }
     if (loginType === PasswordlessLoginValidateWhatSources.MOBILE) {
-      const smsService = this.smsFactory.getSmsService();
-      smsService.sendSMSUsingTemplate(
-        user.mobile,
-        "otp-on-login",
-        {
-          solidAppName:
-            this.settingService.getConfigValue<SolidCoreSetting>("appTitle"),
-          otp: user.mobileVerificationTokenOnLogin,
-          mobileVerificationTokenOnLogin: user.mobileVerificationTokenOnLogin,
-          firstName: user.username,
-          fullName: user.fullName ? user.fullName : user.username,
-          companyLogoUrl: companyLogo,
-        },
-        this.settingService.getConfigValue<SolidCoreSetting>("shouldQueueSms"),
+      const templateParams = {
+        solidAppName:
+          this.settingService.getConfigValue<SolidCoreSetting>("appTitle"),
+        otp: user.mobileVerificationTokenOnLogin,
+        mobileVerificationTokenOnLogin: user.mobileVerificationTokenOnLogin,
+        firstName: user.username,
+        fullName: user.fullName ? user.fullName : user.username,
+        companyLogoUrl: companyLogo,
+      };
+
+      const whatsappDestination = this.normalizeWhatsAppDestination(user.mobile);
+      const gupshupTemplateAppName =
+        process.env.COMMON_GUPSHUP_APP_NAME || "Gupshup";
+      const whatsappTemplateId =
+        this.settingService.getConfigValue<SolidCoreSetting>(
+          "otpWhatsappTemplateId",
+        ) || "common_otp";
+      const whatsappIndependentEnabled =
+        this.settingService.getConfigValue<SolidCoreSetting>(
+          "otpWhatsappIndependentEnabled",
+        ) !== false;
+
+      let smsSent = false;
+      let whatsappSent = false;
+      let smsErrorMessage: string | undefined;
+      let whatsappErrorMessage: string | undefined;
+
+      this.logger.debug(
+        `OTP LOGIN SMS send attempt: destination=${user.mobile}, whatsappDestination=${whatsappDestination}`,
       );
+
+      try {
+        const smsService = this.smsFactory.getSmsService();
+        await smsService.sendSMSUsingTemplate(
+          user.mobile,
+          "otp-on-login",
+          templateParams,
+          false,
+        );
+        smsSent = true;
+      } catch (smsError: any) {
+        smsErrorMessage = smsError?.message;
+        this.logger.warn(
+          `OTP LOGIN SMS failed: destination=${user.mobile}, message=${smsErrorMessage}`,
+        );
+      }
+
+      if (whatsappIndependentEnabled) {
+        if (!whatsappDestination) {
+          whatsappErrorMessage = "Normalized WhatsApp destination is empty";
+          this.logger.error(
+            `OTP LOGIN WhatsApp skipped: destination=${user.mobile}, message=${whatsappErrorMessage}`,
+          );
+        } else {
+          this.logger.debug(
+            `OTP LOGIN WhatsApp send attempt: destination=${user.mobile}, whatsappDestination=${whatsappDestination}, templateId=${whatsappTemplateId}`,
+          );
+          try {
+            await this.sendOtpToWhatsappProvider(
+              whatsappDestination,
+              String(whatsappTemplateId),
+              String(gupshupTemplateAppName),
+              String(templateParams.otp || ""),
+            );
+            whatsappSent = true;
+            this.logger.log(
+              `OTP LOGIN WhatsApp success: destination=${user.mobile}, whatsappDestination=${whatsappDestination}, templateId=${whatsappTemplateId}`,
+            );
+          } catch (waError: any) {
+            whatsappErrorMessage = waError?.message;
+            this.logger.error(
+              `OTP LOGIN WhatsApp failed: destination=${user.mobile}, whatsappDestination=${whatsappDestination}, templateId=${whatsappTemplateId}, message=${whatsappErrorMessage}`,
+            );
+          }
+        }
+      }
+
+      if (!smsSent && !whatsappSent) {
+        throw new Error(
+          `OTP LOGIN delivery failed on both channels. smsError=${smsErrorMessage || "unknown"}, whatsappError=${whatsappErrorMessage || "disabled/unknown"}`,
+        );
+      }
     }
   }
 
@@ -1335,12 +1560,10 @@ export class AuthenticationService {
       const user = await this.resolveUserByVerificationToken(
         confirmForgotPasswordDto.verificationToken,
       );
-      if (!user)
-        throw new UnauthorizedException(ERROR_MESSAGES.INVALID_CREDENTIALS);
+      if (!user) throw new UnauthorizedException("Invalid verification token");
       if (user.lastLoginProvider !== "local")
         throw new UnauthorizedException(ERROR_MESSAGES.INVALID_CREDENTIALS);
-      if (!user.active)
-        throw new UnauthorizedException(ERROR_MESSAGES.INVALID_CREDENTIALS);
+      if (!user.active) throw new UnauthorizedException("User is inactive");
 
       // 1) Atomically consume the token (only one request can succeed)
       const { affected } = await m
@@ -1548,7 +1771,7 @@ export class AuthenticationService {
         accessToken: await this.generateAccessToken(user),
         refreshToken: currentRefreshToken,
       };
-    } catch (err) {
+    } catch (err: any) {
       if (err instanceof InvalidatedRefreshTokenError) {
         // Take action: notify user that his refresh token might have been stolen?
         throw new UnauthorizedException(ERROR_MESSAGES.ACCESS_DENIED);
@@ -1599,7 +1822,7 @@ export class AuthenticationService {
       } else {
         throw new UnauthorizedException(ERROR_MESSAGES.INVALID_USER_PROFILE);
       }
-    } catch (error) {
+    } catch (error: any) {
       throw new UnauthorizedException(
         ERROR_MESSAGES.GOOGLE_OAUTH_PROFILE_FETCH_FAILED,
       );
@@ -1668,7 +1891,7 @@ export class AuthenticationService {
       } else {
         throw new UnauthorizedException(ERROR_MESSAGES.INVALID_USER_PROFILE);
       }
-    } catch (error) {
+    } catch (error: any) {
       if (error instanceof UnauthorizedException) {
         throw error;
       }
@@ -1733,7 +1956,7 @@ export class AuthenticationService {
       } else {
         throw new UnauthorizedException(ERROR_MESSAGES.INVALID_USER_PROFILE);
       }
-    } catch (error) {
+    } catch (error: any) {
       throw new UnauthorizedException("Microsoft OAuth profile fetch failed");
     }
   }
@@ -1880,7 +2103,7 @@ export class AuthenticationService {
       await this.userActivityHistoryService.logEvent("logout", user);
 
       return { message: SUCCESS_MESSAGES.LOGOUT_SUCCESS };
-    } catch (err) {
+    } catch (err: any) {
       throw err instanceof UnauthorizedException ||
         err instanceof InternalServerErrorException
         ? err