@solidxai/core 0.1.10-beta.15 → 0.1.10-beta.21

package/src/services/settings/default-settings-provider.service.ts

@@ -779,6 +779,46 @@ const getSolidCoreSettings = (isProd: boolean) =>
       value: parseInt(process.env.IAM_OTP_EXPIRY ?? "10"),
       level: SettingLevel.SystemEnv,
     },
+    {
+      moduleName: "solid-core",
+      key: "otpWhatsappFallbackEnabled",
+      value: (process.env.IAM_OTP_WHATSAPP_FALLBACK_ENABLED ?? "true") === "true",
+      level: SettingLevel.SystemAdminEditable,
+      label: "OTP WhatsApp Fallback Enabled",
+      group: "authentication-settings",
+      sortOrder: 85,
+      controlType: "boolean",
+    },
+    {
+      moduleName: "solid-core",
+      key: "otpWhatsappTemplateId",
+      value: process.env.IAM_OTP_WHATSAPP_TEMPLATE_ID ?? "common_otp",
+      level: SettingLevel.SystemAdminEditable,
+      label: "OTP WhatsApp Template ID",
+      group: "authentication-settings",
+      sortOrder: 86,
+      controlType: "shortText",
+    },
+    {
+      moduleName: "solid-core",
+      key: "otpWhatsappIndependentEnabled",
+      value: (process.env.IAM_OTP_WHATSAPP_INDEPENDENT_ENABLED ?? "true") === "true",
+      level: SettingLevel.SystemAdminEditable,
+      label: "OTP WhatsApp Independent Enabled",
+      group: "authentication-settings",
+      sortOrder: 87,
+      controlType: "boolean",
+    },
+    {
+      moduleName: "solid-core",
+      key: "otpDefaultCountryDialCode",
+      value: process.env.IAM_OTP_DEFAULT_COUNTRY_DIAL_CODE ?? "",
+      level: SettingLevel.SystemAdminEditable,
+      label: "OTP Default Country Dial Code",
+      group: "authentication-settings",
+      sortOrder: 88,
+      controlType: "shortText",
+    },
     {
       moduleName: "solid-core",
       key: "forgotPasswordVerificationTokenExpiry",
@@ -1178,6 +1218,64 @@ const getSolidCoreSettings = (isProd: boolean) =>
       sortOrder: 30,
       controlType: "shortText",
     },
+    {
+      moduleName: "solid-core",
+      key: "metaWhatsappApiUrl",
+      value: process.env.COMMON_META_WHATSAPP_API_URL || "https://graph.facebook.com",
+      level: SettingLevel.SystemAdminReadonly,
+      label: "Meta WhatsApp API URL",
+      group: "whatsapp-settings",
+      sortOrder: 40,
+      controlType: "shortText",
+    },
+    {
+      moduleName: "solid-core",
+      key: "metaWhatsappApiVersion",
+      value: process.env.COMMON_META_WHATSAPP_API_VERSION || "v23.0",
+      level: SettingLevel.SystemAdminReadonly,
+      label: "Meta WhatsApp API Version",
+      group: "whatsapp-settings",
+      sortOrder: 50,
+      controlType: "shortText",
+    },
+    {
+      moduleName: "solid-core",
+      key: "metaWhatsappPhoneNumberId",
+      value: process.env.COMMON_META_WHATSAPP_PHONE_NUMBER_ID,
+      level: SettingLevel.SystemAdminReadonly,
+      label: "Meta WhatsApp Phone Number ID",
+      group: "whatsapp-settings",
+      sortOrder: 60,
+      controlType: "shortText",
+    },
+    {
+      moduleName: "solid-core",
+      key: "metaWhatsappBusinessAccountId",
+      value: process.env.COMMON_META_WHATSAPP_BUSINESS_ACCOUNT_ID,
+      level: SettingLevel.SystemAdminReadonly,
+      label: "Meta WhatsApp Business Account ID",
+      group: "whatsapp-settings",
+      sortOrder: 70,
+      controlType: "shortText",
+    },
+    {
+      moduleName: "solid-core",
+      key: "metaWhatsappAccessToken",
+      value: process.env.COMMON_META_WHATSAPP_ACCESS_TOKEN,
+      level: SettingLevel.SystemEnv,
+    },
+    {
+      moduleName: "solid-core",
+      key: "metaWhatsappWebhookVerifyToken",
+      value: process.env.COMMON_META_WHATSAPP_WEBHOOK_VERIFY_TOKEN,
+      level: SettingLevel.SystemEnv,
+    },
+    {
+      moduleName: "solid-core",
+      key: "metaWhatsappAppSecret",
+      value: process.env.COMMON_META_WHATSAPP_APP_SECRET,
+      level: SettingLevel.SystemEnv,
+    },
   ] as const satisfies SettingDefinition[];
 
 // 2.

package/src/services/user.service.ts

@@ -285,7 +285,7 @@ export class UserService extends CRUDService<User> {
   }
 
   async resolveUserOnOauthFacebook(oauthUserDto: OauthUserDto): Promise<User> {
-    const normalizedEmail = oauthUserDto.email?.trim().toLowerCase() || null;
+    const normalizedEmail = oauthUserDto.email?.trim().toLowerCase();
     let user: User | null = null;
 
     if (oauthUserDto.providerId) {

package/src/services/whatsapp/GupshupOtpWhatsappService.ts

@@ -0,0 +1,174 @@
+import { HttpService } from "@nestjs/axios";
+import { Injectable, Logger } from "@nestjs/common";
+import { AxiosError } from "axios";
+import { WhatsAppProvider } from "src/decorators/whatsapp-provider.decorator";
+import { IWhatsAppTransport } from "src/interfaces";
+
+@Injectable()
+@WhatsAppProvider()
+export class GupshupOtpWhatsappService implements IWhatsAppTransport {
+  private readonly logger = new Logger(GupshupOtpWhatsappService.name);
+
+  constructor(private readonly httpService: HttpService) {}
+
+  async sendWhatsAppMessage(
+    to: string,
+    templateId: string,
+    parameters: any,
+    parentEntity?: any,
+    parentEntityId?: any,
+  ): Promise<any> {
+    if (!to) {
+      throw new Error("WhatsApp destination number is required");
+    }
+
+    const payload = parameters?.payload;
+    if (payload?.message?.type === "text" && payload?.message?.text) {
+      await this.sendTextMessage(
+        payload.destination || to,
+        payload.message.text,
+        payload.source,
+        payload["src.name"],
+      );
+      return { to, templateId, parameters, parentEntity, parentEntityId };
+    }
+
+    if (parameters?.type === "text" && parameters?.text) {
+      await this.sendTextMessage(to, parameters.text);
+      return { to, templateId, parameters, parentEntity, parentEntityId };
+    }
+
+    if (!templateId) {
+      throw new Error("WhatsApp templateId is required for template message");
+    }
+
+    const bodyParams = Array.isArray(parameters)
+      ? parameters
+      : Array.isArray(parameters?.body)
+        ? parameters.body
+        : [];
+
+    await this.sendOtpTemplate(to, templateId, bodyParams.map((x) => String(x)));
+    return { to, templateId, parameters, parentEntity, parentEntityId };
+  }
+
+  private async sendTextMessage(
+    destination: string,
+    text: string,
+    sourceOverride?: string,
+    appNameOverride?: string,
+  ): Promise<void> {
+    const apiKey =
+      process.env.COMMON_GUPSHUP_WHATSAPP_API_KEY ||
+      process.env.GUPSHUP_API_KEY;
+    const msgUrl =
+      process.env.COMMON_GUPSHUP_WHATSAPP_API_URL ||
+      process.env.GUPSHUP_API_URL ||
+      "https://api.gupshup.io/wa/api/v1/msg";
+    const source =
+      sourceOverride ||
+      process.env.COMMON_GUPSHUP_WHATSAPP_SOURCE ||
+      process.env.GUPSHUP_SOURCE_NUMBER;
+    const appName =
+      appNameOverride || process.env.COMMON_GUPSHUP_APP_NAME || "solidx";
+
+    if (!apiKey || !msgUrl || !source) {
+      throw new Error("Missing Gupshup WhatsApp configuration for text message");
+    }
+
+    const rawDestination = destination.replace(/\D/g, "");
+    const params = new URLSearchParams();
+    params.append("channel", "whatsapp");
+    params.append("source", source);
+    params.append("destination", rawDestination);
+    params.append("src.name", appName);
+    params.append("message", JSON.stringify({ type: "text", text }));
+
+    await this.httpService.axiosRef.post(msgUrl, params.toString(), {
+      headers: {
+        apikey: apiKey,
+        "Content-Type": "application/x-www-form-urlencoded",
+      },
+    });
+  }
+
+  async sendOtpTemplate(
+    destination: string,
+    templateId: string,
+    bodyParams: string[],
+  ): Promise<void> {
+    const apiKey =
+      process.env.COMMON_GUPSHUP_WHATSAPP_API_KEY ||
+      process.env.GUPSHUP_API_KEY;
+    const baseUrl =
+      process.env.COMMON_GUPSHUP_WHATSAPP_API_URL ||
+      process.env.GUPSHUP_API_URL ||
+      "https://api.gupshup.io/wa/api/v1/msg";
+    const templateUrl =
+      process.env.COMMON_GUPSHUP_WHATSAPP_TEMPLATE_API_URL ||
+      baseUrl.replace(/\/msg$/, "/template/msg");
+    const source =
+      process.env.COMMON_GUPSHUP_WHATSAPP_SOURCE ||
+      process.env.GUPSHUP_SOURCE_NUMBER;
+    const appName = process.env.COMMON_GUPSHUP_APP_NAME || "solidx";
+
+    if (!apiKey || !templateUrl || !source) {
+      throw new Error("Missing Gupshup OTP WhatsApp configuration");
+    }
+
+    if (!destination || !String(destination).trim()) {
+      throw new Error("WhatsApp destination is empty");
+    }
+
+    try {
+      const rawDestination = destination.replace(/\D/g, "");
+      const params = new URLSearchParams();
+      params.append("channel", "whatsapp");
+      params.append("source", source);
+      params.append("destination", rawDestination);
+      params.append(
+        "to",
+        rawDestination.startsWith("+")
+          ? rawDestination
+          : `+${rawDestination}`,
+      );
+      params.append("src.name", appName);
+      params.append(
+        "template",
+        JSON.stringify({
+          id: templateId,
+          params: bodyParams,
+        }),
+      );
+
+      this.logger.debug(
+        `Gupshup OTP outbound (template): endpoint=${templateUrl}, source=${source}, destination=${rawDestination}, to=${rawDestination.startsWith("+") ? rawDestination : `+${rawDestination}`}, templateId=${templateId}, params=${JSON.stringify(bodyParams)}`,
+      );
+
+      const response = await this.httpService.axiosRef.post(
+        templateUrl,
+        params.toString(),
+        {
+          headers: {
+            apikey: apiKey,
+            "Content-Type": "application/x-www-form-urlencoded",
+          },
+        },
+      );
+
+      this.logger.debug(
+        `Gupshup response: ${response.status}, data=${JSON.stringify(response.data)}`,
+      );
+
+      this.logger.debug(
+        `Independent OTP WhatsApp sent to ${rawDestination} template=${templateId} via template endpoint`,
+      );
+    } catch (error) {
+      const axiosError = error as AxiosError;
+      this.logger.error(
+        `Independent OTP WhatsApp failed: destination=${destination}, templateId=${templateId}, status=${axiosError.response?.status ?? "unknown"}, response=${typeof axiosError.response?.data === "object" ? JSON.stringify(axiosError.response?.data) : axiosError.response?.data}, url=${templateUrl}`,
+      );
+      throw error;
+    }
+  }
+}

package/src/services/whatsapp/MetaCloudWhatsappService.ts

@@ -0,0 +1,253 @@
+import { HttpService } from "@nestjs/axios";
+import { Injectable, Logger } from "@nestjs/common";
+import { AxiosError } from "axios";
+import { WhatsAppProvider } from "src/decorators/whatsapp-provider.decorator";
+import { IWhatsAppTransport } from "src/interfaces";
+import { QueueMessage } from "src/interfaces/mq";
+import { SettingService } from "src/services/setting.service";
+import type { SolidCoreSetting } from "src/services/settings/default-settings-provider.service";
+
+type MetaTemplatePayload = {
+  type?: "template";
+  templateName?: string;
+  templateId?: string;
+  languageCode?: string;
+  body?: string[];
+  headerText?: string;
+  imageLink?: string;
+};
+
+type MetaTextPayload = {
+  type?: "text";
+  text?: string;
+  previewUrl?: boolean;
+};
+
+@Injectable()
+@WhatsAppProvider()
+export class MetaCloudWhatsappService implements IWhatsAppTransport {
+  readonly logger = new Logger(MetaCloudWhatsappService.name);
+
+  constructor(
+    private readonly httpService: HttpService,
+    private readonly settingService: SettingService,
+  ) {}
+
+  async sendWhatsAppMessage(
+    to: string,
+    templateId: string,
+    parameters: any,
+    parentEntity?: any,
+    parentEntityId?: any,
+  ): Promise<any> {
+    const message: QueueMessage<any> = {
+      payload: {
+        to,
+        templateId,
+        ...parameters,
+      },
+      parentEntity,
+      parentEntityId,
+    };
+
+    await this.sendWhatsAppMessageSynchronously(message);
+    return message;
+  }
+
+  async sendWhatsAppMessageSynchronously(message: QueueMessage<any>): Promise<void> {
+    const phoneNumberId = this.settingService.getConfigValue<SolidCoreSetting>(
+      "metaWhatsappPhoneNumberId",
+    );
+    const apiVersion = this.settingService.getConfigValue<SolidCoreSetting>(
+      "metaWhatsappApiVersion",
+    );
+    const apiBaseUrl = this.settingService.getConfigValue<SolidCoreSetting>(
+      "metaWhatsappApiUrl",
+    );
+    const accessToken = this.settingService.getConfigValue<SolidCoreSetting>(
+      "metaWhatsappAccessToken",
+    );
+
+    if (!phoneNumberId || !apiVersion || !apiBaseUrl || !accessToken) {
+      throw new Error(
+        "Missing Meta WhatsApp configuration. Set metaWhatsappApiUrl, metaWhatsappApiVersion, metaWhatsappPhoneNumberId, metaWhatsappAccessToken.",
+      );
+    }
+
+    const requestBody = this.createWhatsappRequest(message);
+    const url = `${String(apiBaseUrl).replace(/\/$/, "")}/${apiVersion}/${phoneNumberId}/messages`;
+
+    try {
+      await this.httpService.axiosRef.post(url, requestBody, {
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json",
+        },
+      });
+      this.logger.debug(
+        `Sent Meta WhatsApp message to ${message.payload?.to} with type ${requestBody.type}`,
+      );
+    } catch (error) {
+      const axiosError = error as AxiosError;
+      const status = axiosError.response?.status;
+      const data = axiosError.response?.data;
+      this.logger.error(
+        `Meta WhatsApp send failed: status=${status ?? "unknown"}, url=${url}, response=${typeof data === "object" ? JSON.stringify(data) : data}`,
+      );
+      throw error;
+    }
+  }
+
+  private createWhatsappRequest(message: QueueMessage<any>): any {
+    const payload = message?.payload ?? {};
+
+    if (payload?.payload) {
+      const normalizedFromWrappedPayload = this.normalizeWrappedPayload(payload.payload);
+      if (normalizedFromWrappedPayload) {
+        return normalizedFromWrappedPayload;
+      }
+      return payload.payload;
+    }
+
+    const to = this.normalizePhone(payload.to);
+    const templatePayload: MetaTemplatePayload = payload;
+    const textPayload: MetaTextPayload = payload;
+
+    if (textPayload.type === "text" || textPayload.text) {
+      return {
+        messaging_product: "whatsapp",
+        recipient_type: "individual",
+        to,
+        type: "text",
+        text: {
+          body: textPayload.text ?? "",
+          preview_url: Boolean(textPayload.previewUrl),
+        },
+      };
+    }
+
+    const templateName = payload.templateId || templatePayload.templateId || templatePayload.templateName;
+    if (!templateName) {
+      throw new Error(
+        "Meta WhatsApp template name is missing. Provide templateId or parameters.templateName.",
+      );
+    }
+
+    const components: any[] = [];
+    if (templatePayload.headerText) {
+      components.push({
+        type: "header",
+        parameters: [
+          {
+            type: "text",
+            text: templatePayload.headerText,
+          },
+        ],
+      });
+    } else if (templatePayload.imageLink) {
+      components.push({
+        type: "header",
+        parameters: [
+          {
+            type: "image",
+            image: { link: templatePayload.imageLink },
+          },
+        ],
+      });
+    }
+
+    if (Array.isArray(templatePayload.body) && templatePayload.body.length > 0) {
+      components.push({
+        type: "body",
+        parameters: templatePayload.body.map((entry) => ({
+          type: "text",
+          text: String(entry),
+        })),
+      });
+    }
+
+    return {
+      messaging_product: "whatsapp",
+      recipient_type: "individual",
+      to,
+      type: "template",
+      template: {
+        name: templateName,
+        language: {
+          code: templatePayload.languageCode || "en",
+        },
+        ...(components.length > 0 ? { components } : {}),
+      },
+    };
+  }
+
+  private normalizeWrappedPayload(payload: any): any | null {
+    if (!payload || typeof payload !== "object") {
+      return null;
+    }
+
+    if (payload.messaging_product && payload.to && payload.type) {
+      return payload;
+    }
+
+    const destination = payload.destination || payload.to;
+    const message = payload.message || {};
+    if (!destination || !message.type) {
+      return null;
+    }
+
+    if (message.type === "text" && message.text) {
+      return {
+        messaging_product: "whatsapp",
+        recipient_type: "individual",
+        to: this.normalizePhone(destination),
+        type: "text",
+        text: {
+          body: String(message.text),
+          preview_url: false,
+        },
+      };
+    }
+
+    if (message.type === "template" && message.template?.id) {
+      const params = Array.isArray(message.template?.params)
+        ? message.template.params
+        : [];
+      return {
+        messaging_product: "whatsapp",
+        recipient_type: "individual",
+        to: this.normalizePhone(destination),
+        type: "template",
+        template: {
+          name: String(message.template.id),
+          language: {
+            code: "en",
+          },
+          ...(params.length > 0
+            ? {
+                components: [
+                  {
+                    type: "body",
+                    parameters: params.map((entry: any) => ({
+                      type: "text",
+                      text: String(entry),
+                    })),
+                  },
+                ],
+              }
+            : {}),
+        },
+      };
+    }
+
+    return null;
+  }
+
+  private normalizePhone(phone: string): string {
+    const digits = String(phone || "").replace(/\D/g, "");
+    if (!digits) {
+      throw new Error("Destination phone number is required for WhatsApp message.");
+    }
+    return digits;
+  }
+}