@dev.smartpricing/message-composer-utils 4.3.2-fix.1 → 4.4.1-next.0

package/src/utils/templates/whatsapp-compiler.test.ts

@@ -0,0 +1,282 @@
+import { describe, it, expect } from "vitest";
+import type { JSONContent } from "@tiptap/core";
+import type { WhatsappMessage } from "../../types/index.js";
+import {
+  compileWhatsappTemplate,
+  extractRequiredParameters,
+  validateParameters,
+} from "./whatsapp-compiler.js";
+import {
+  mergeBrandDataParams,
+  type BrandCascadeData,
+} from "./brand-cascade.js";
+
+const mention = (label: string): JSONContent => ({
+  type: "mention",
+  attrs: { id: label, label },
+});
+const text = (value: string): JSONContent => ({ type: "text", text: value });
+const doc = (...content: JSONContent[]): JSONContent => ({
+  type: "doc",
+  content: [{ type: "paragraph", content }],
+});
+
+/** An approved, submitted WhatsApp Message with every block empty by default. */
+function whatsappMessage(
+  body: Partial<WhatsappMessage["body"]> = {},
+): WhatsappMessage {
+  return {
+    id: "msg-1",
+    created_at: new Date("2026-09-01T00:00:00.000Z"),
+    updated_at: new Date("2026-09-01T00:00:00.000Z"),
+    message_group_id: "group-1",
+    language_id: "en",
+    status: "approved",
+    render_type: "whatsapp_v1",
+    user_id: "user-1",
+    body: {
+      header: { type: "none" },
+      body: { enabled: true, content: undefined },
+      footer: { enabled: false, content: "" },
+      buttons: { enabled: false, buttons: [] },
+      ...body,
+    },
+    metadata: {
+      meta: {
+        template_id: "1234567890",
+        template_name: "welcome_en",
+        submission_date: "2026-09-01T00:00:00.000Z",
+        translated_template: {
+          name: "welcome_en",
+          language: "en",
+          category: "UTILITY",
+          parameter_format: "NAMED",
+          allow_category_change: false,
+          components: [],
+        },
+      },
+    },
+  };
+}
+
+describe("extractRequiredParameters", () => {
+  it("lists header, body and URL button keys once each, in template order", () => {
+    const message = whatsappMessage({
+      header: {
+        type: "text",
+        content: doc(text("Hi "), mention("guest_name")),
+      },
+      body: {
+        enabled: true,
+        content: doc(
+          mention("guest_name"),
+          text(" your stay at "),
+          mention("brand_name"),
+          text(" starts "),
+          mention("check_in"),
+        ),
+      },
+      buttons: {
+        enabled: true,
+        buttons: [
+          {
+            id: "b1",
+            type: "link",
+            text: "Open",
+            url: "https://example.com/{{booking_id}}?guest={{guest_name}}",
+          },
+        ],
+      },
+    });
+
+    expect(extractRequiredParameters(message)).toEqual([
+      "guest_name",
+      "brand_name",
+      "check_in",
+      "booking_id",
+    ]);
+  });
+
+  it("returns no keys for a template without variables", () => {
+    const message = whatsappMessage({
+      body: { enabled: true, content: doc(text("Plain text")) },
+    });
+    expect(extractRequiredParameters(message)).toEqual([]);
+  });
+
+  it("ignores URL buttons when the button block is disabled", () => {
+    const message = whatsappMessage({
+      buttons: {
+        enabled: false,
+        buttons: [
+          { id: "b1", type: "link", text: "Open", url: "https://x/{{id}}" },
+        ],
+      },
+    });
+    expect(extractRequiredParameters(message)).toEqual([]);
+  });
+});
+
+describe("validateParameters with brand_* keys", () => {
+  const message = whatsappMessage({
+    body: {
+      enabled: true,
+      content: doc(mention("guest_name"), text(" @ "), mention("brand_name")),
+    },
+  });
+  const brand: BrandCascadeData = {
+    default_email_settings: {},
+    default_button_settings: {},
+    default_socials: null,
+    logo_url: null,
+    data: { name: "Hotel Sole" },
+  };
+
+  it("reports brand_name missing when validated on the raw parameters", () => {
+    expect(validateParameters(message, { guest_name: "Mario" })).toEqual({
+      valid: false,
+      required: ["guest_name", "brand_name"],
+      missing: ["brand_name"],
+    });
+  });
+
+  it("counts brand_name as present once the Brand data is merged in", () => {
+    const merged = mergeBrandDataParams({ guest_name: "Mario" }, brand);
+    expect(validateParameters(message, merged)).toEqual({
+      valid: true,
+      required: ["guest_name", "brand_name"],
+      missing: [],
+    });
+  });
+
+  it("still reports a brand_* key the Brand cannot supply", () => {
+    const withSlogan = whatsappMessage({
+      body: { enabled: true, content: doc(mention("brand_slogan")) },
+    });
+    const merged = mergeBrandDataParams({}, brand);
+    expect(validateParameters(withSlogan, merged).missing).toEqual([
+      "brand_slogan",
+    ]);
+  });
+});
+
+describe("compileWhatsappTemplate", () => {
+  it("builds the template envelope from the Meta metadata and language", () => {
+    const payload = compileWhatsappTemplate(whatsappMessage(), {});
+    expect(payload).toEqual({
+      messaging_product: "whatsapp",
+      type: "template",
+      template: {
+        name: "welcome_en",
+        language: { code: "en" },
+        components: undefined,
+      },
+    });
+  });
+
+  it("throws when the Message has no Meta template name", () => {
+    const message = whatsappMessage();
+    message.metadata = {};
+    expect(() => compileWhatsappTemplate(message, {})).toThrow(
+      "Message does not have Meta template name in metadata",
+    );
+  });
+
+  it("emits a HEADER component with the header text variable", () => {
+    const message = whatsappMessage({
+      header: {
+        type: "text",
+        content: doc(text("Hi "), mention("guest_name")),
+      },
+    });
+    const payload = compileWhatsappTemplate(message, { guest_name: "Mario" });
+    expect(payload.template.components).toEqual([
+      {
+        type: "HEADER",
+        parameters: [
+          { type: "text", text: "Mario", parameter_name: "guest_name" },
+        ],
+      },
+    ]);
+  });
+
+  it("emits BODY named parameters in order, coercing values to strings", () => {
+    const message = whatsappMessage({
+      body: {
+        enabled: true,
+        content: doc(
+          mention("guest_name"),
+          text(", "),
+          mention("nights"),
+          text(" nights, "),
+          mention("missing_key"),
+        ),
+      },
+    });
+    const payload = compileWhatsappTemplate(message, {
+      guest_name: "Mario",
+      nights: 3,
+    });
+    expect(payload.template.components).toEqual([
+      {
+        type: "BODY",
+        parameters: [
+          { type: "text", text: "Mario", parameter_name: "guest_name" },
+          { type: "text", text: "3", parameter_name: "nights" },
+          { type: "text", text: "", parameter_name: "missing_key" },
+        ],
+      },
+    ]);
+  });
+
+  it("emits a media HEADER by smartchat media id", () => {
+    const message = whatsappMessage({
+      header: {
+        type: "image",
+        url: "https://cdn.example.com/hero.png",
+        smartchatMediaId: "media-42",
+      },
+    });
+    const payload = compileWhatsappTemplate(message, {});
+    expect(payload.template.components).toEqual([
+      {
+        type: "HEADER",
+        parameters: [{ type: "image", image: { id: "media-42" } }],
+      },
+    ]);
+  });
+
+  it("omits the media HEADER when the media id is not resolved", () => {
+    const message = whatsappMessage({
+      header: { type: "image", url: "https://cdn.example.com/hero.png" },
+    });
+    const payload = compileWhatsappTemplate(message, {});
+    expect(payload.template.components).toBeUndefined();
+  });
+
+  it("emits a URL BUTTON component named by button position, as submitted to Meta", () => {
+    const message = whatsappMessage({
+      buttons: {
+        enabled: true,
+        buttons: [
+          { id: "b0", type: "quick_reply", text: "Yes" },
+          {
+            id: "b1",
+            type: "link",
+            text: "Open",
+            url: "https://example.com/{{booking_id}}",
+          },
+        ],
+      },
+    });
+    const payload = compileWhatsappTemplate(message, { booking_id: "abc" });
+    expect(payload.template.components).toEqual([
+      {
+        type: "BUTTON",
+        sub_type: "url",
+        index: "1",
+        parameters: [{ type: "text", text: "abc", parameter_name: "{{2}}" }],
+      },
+    ]);
+  });
+});