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

package/src/utils/templates/meta.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, it } from "vitest";
+import type { JSONContent } from "@tiptap/core";
+import type {
+  MetaHeaderComponent,
+  WhatsappMessage,
+  WithDbTimestamps,
+} from "../../types/index.js";
+import { translateWhatsappToMeta } from "./meta.js";
+import { getWhatsappEmpty } from "./whatsapp.js";
+
+function messageWithHeader(
+  content: JSONContent,
+): WithDbTimestamps<WhatsappMessage> {
+  const base = getWhatsappEmpty("en");
+  return {
+    ...base,
+    id: "msg-1",
+    body: {
+      ...base.body,
+      header: { type: "text", content },
+      body: {
+        enabled: true,
+        content: {
+          type: "doc",
+          content: [
+            { type: "paragraph", content: [{ type: "text", text: "Body" }] },
+          ],
+        },
+      },
+    },
+    created_at: "2026-01-01T00:00:00.000Z",
+    updated_at: "2026-01-01T00:00:00.000Z",
+  } as WithDbTimestamps<WhatsappMessage>;
+}
+
+function headerText(content: JSONContent): string | undefined {
+  const template = translateWhatsappToMeta(
+    messageWithHeader(content),
+    "group",
+    "utility",
+    "pfx",
+    "en",
+  );
+  const header = template.components.find(
+    (c): c is MetaHeaderComponent => c.type === "HEADER",
+  );
+  return header && "text" in header ? header.text : undefined;
+}
+
+describe("translateWhatsappToMeta header", () => {
+  it("sends header text to Meta without WhatsApp formatting markers", () => {
+    const content: JSONContent = {
+      type: "doc",
+      content: [
+        {
+          type: "paragraph",
+          content: [
+            { type: "text", text: "Your ", marks: [{ type: "bold" }] },
+            { type: "text", text: "stay", marks: [{ type: "italic" }] },
+            { type: "text", text: " is confirmed" },
+          ],
+        },
+      ],
+    };
+
+    expect(headerText(content)).toBe("Your stay is confirmed");
+  });
+
+  it("sends header text to Meta without emojis", () => {
+    const content: JSONContent = {
+      type: "doc",
+      content: [
+        {
+          type: "paragraph",
+          content: [
+            { type: "text", text: "Welcome " },
+            { type: "emoji", attrs: { name: "wave" } },
+            { type: "text", text: " {{guest_name}}" },
+          ],
+        },
+      ],
+    };
+
+    expect(headerText(content)).toBe("Welcome  {{guest_name}}");
+  });
+});

package/src/utils/templates/meta.ts

@@ -16,7 +16,10 @@ import {
   WA_HEADER_TEXT_MAX_LENGTH,
   WA_FOOTER_MAX_LENGTH,
 } from "../../types/index.js";
-import { convertToWhatsappMarkdown } from "./whatsapp.js";
+import {
+  convertToWhatsappHeaderText,
+  convertToWhatsappMarkdown,
+} from "./whatsapp.js";
 
 /**
  * Generates a unique template name for Meta
@@ -135,7 +138,7 @@ function translateHeaderToMeta(
     }
     case "text": {
       if (!header.content) return null;
-      const text = convertToWhatsappMarkdown(header.content);
+      const text = convertToWhatsappHeaderText(header.content);
       const exampleContent = generateExampleContent(text, "header");
 
       const result: MetaHeaderComponent = {

package/src/utils/templates/tiptap.ts

@@ -67,11 +67,8 @@ const PRESETS: Record<
     italic: true,
     emoji: true,
   },
-  "whatsapp-header": {
-    bold: true,
-    italic: true,
-    emoji: true,
-  },
+  // Meta rejects formatting and emojis in header text
+  "whatsapp-header": {},
   email: {
     bold: true,
     italic: true,

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}}" }],
+      },
+    ]);
+  });
+});

package/src/utils/templates/whatsapp.ts

@@ -78,13 +78,13 @@ export function isWhatsappValid(
     };
   }
 
-  // Validate header text length (use markdown output to match what Meta receives)
+  // Validate header text length (use the text Meta receives)
   if (
     message.body.header.type === "text" &&
     message.body.header.content &&
     !isContentEmpty(message.body.header.content)
   ) {
-    const headerText = convertToWhatsappMarkdown(message.body.header.content);
+    const headerText = convertToWhatsappHeaderText(message.body.header.content);
     if (headerText.length > WA_HEADER_TEXT_MAX_LENGTH) {
       errors.push("editor.validation.error.headerTooLong");
     }
@@ -305,6 +305,33 @@ export function convertToWhatsappMarkdown(
   return processNode(content);
 }
 
+/**
+ * Converts a WhatsApp header to the text Meta receives.
+ * Meta rejects formatting in header text ("Header Format is Incorrect",
+ * subcode 2388072), so marks and emoji nodes are dropped — including on
+ * legacy content saved before the header editor stopped offering them.
+ */
+export function convertToWhatsappHeaderText(
+  content: Content | undefined,
+): string {
+  return convertToWhatsappMarkdown(toPlainHeader(content));
+}
+
+function toPlainHeader(content: Content | undefined): Content | undefined {
+  if (Array.isArray(content))
+    return content.map((n) => toPlainHeader(n) as JSONContent);
+  if (!content || typeof content !== "object") return content;
+  const { marks: _marks, ...node } = content;
+  return node.content
+    ? {
+        ...node,
+        content: node.content
+          .filter((n) => n.type !== "emoji")
+          .map((n) => toPlainHeader(n) as JSONContent),
+      }
+    : node;
+}
+
 /**
  * Calculates the translation completion percentage for a WhatsApp message
  * Compares against a base message to determine which fields need translation

package/dist/types/api/apiTemplates.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=apiTemplates.js.map

package/dist/types/api/apiTemplates.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"apiTemplates.js","sourceRoot":"","sources":["../../../src/types/api/apiTemplates.ts"],"names":[],"mappings":""}

package/dist/types/template.js

@@ -1,2 +0,0 @@
-export const SYSTEM_USER_ID = "SYSTEM";
-//# sourceMappingURL=template.js.map

package/dist/types/template.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"template.js","sourceRoot":"","sources":["../../src/types/template.ts"],"names":[],"mappings":"AASA,MAAM,CAAC,MAAM,cAAc,GAAG,QAAiB,CAAC"}