@dev.smartpricing/message-composer-utils 3.1.2

package/src/utils/templates/tiptap.ts

@@ -0,0 +1,247 @@
+import { type Content, type Extensions } from "@tiptap/core";
+import { generateJSON } from "@tiptap/html";
+import StarterKit from "@tiptap/starter-kit";
+import Mention from "@tiptap/extension-mention";
+import Emoji, { gitHubEmojis } from "@tiptap/extension-emoji";
+import { CharacterCount } from "@tiptap/extensions";
+import TextAlign from "@tiptap/extension-text-align";
+import type { JSONContent } from "@tiptap/core";
+import { RenderType, WA_BODY_MAX_LENGTH } from "../../types/index.js";
+import { generateHtml, generateText } from "./messages.js";
+
+export interface TipTapExtensionOptions {
+  preset?: "whatsapp" | "whatsapp-header" | "email";
+  bold?: boolean;
+  italic?: boolean;
+  emoji?: boolean;
+  underline?: boolean;
+  link?: boolean;
+  bulletList?: boolean;
+  orderedList?: boolean;
+  textAlign?: boolean;
+  dynamicValues?: boolean;
+  characterLimit?: number;
+  horizontalRule?: boolean;
+  hardBreak?: boolean;
+}
+
+const PRESETS: Record<
+  NonNullable<TipTapExtensionOptions["preset"]>,
+  Omit<TipTapExtensionOptions, "preset" | "dynamicValues" | "characterLimit">
+> = {
+  whatsapp: {
+    bold: true,
+    italic: true,
+    emoji: true,
+  },
+  "whatsapp-header": {
+    bold: true,
+    italic: true,
+    emoji: true,
+  },
+  email: {
+    bold: true,
+    italic: true,
+    emoji: true,
+    underline: true,
+    link: true,
+    bulletList: true,
+    orderedList: true,
+    textAlign: true,
+    horizontalRule: true,
+    hardBreak: true,
+  },
+};
+
+export function getTipTapExtensions(
+  options: TipTapExtensionOptions = {},
+): Extensions {
+  const presetOptions = options.preset ? PRESETS[options.preset] : {};
+  const merged = { ...presetOptions, ...options };
+
+  const {
+    bold = false,
+    italic = false,
+    emoji = false,
+    underline = false,
+    link = false,
+    bulletList = false,
+    orderedList = false,
+    textAlign = false,
+    dynamicValues = true,
+    characterLimit,
+    horizontalRule = false,
+    hardBreak = false,
+  } = merged;
+
+  const extensions: Extensions = [];
+
+  // Add character count if limit is set
+  if (characterLimit) {
+    extensions.push(
+      CharacterCount.configure({
+        limit: characterLimit,
+      }),
+    );
+  }
+
+  // Add mention support if dynamic values are provided
+  if (dynamicValues) {
+    extensions.push(
+      Mention.configure({
+        renderText: (mention) => `{{${mention.node.attrs.label}}}`,
+        renderHTML: (mention) =>
+          `{{${mention.node.attrs.label || mention.node.attrs.id}}}`,
+        HTMLAttributes: {
+          class: "dynamic-data",
+        },
+        deleteTriggerWithBackspace: true,
+      }),
+    );
+  }
+
+  // Add emoji support if enabled
+  if (emoji) {
+    extensions.push(
+      Emoji.configure({
+        emojis: gitHubEmojis,
+        HTMLAttributes: {
+          class: "tiptap-emoji",
+        },
+        suggestion: {
+          char: ":",
+          items: (props) =>
+            gitHubEmojis.filter((emoji) => emoji.name.includes(props.query)),
+        },
+      }),
+    );
+  }
+
+  // Add text align extension if enabled
+  if (textAlign) {
+    extensions.push(
+      TextAlign.configure({
+        types: ["paragraph"],
+      }),
+    );
+  }
+
+  // Configure StarterKit based on enabled features
+  extensions.push(
+    StarterKit.configure({
+      bold: bold ? undefined : false,
+      italic: italic ? undefined : false,
+      underline: underline ? undefined : false,
+      link: link
+        ? {
+            openOnClick: false,
+          }
+        : false,
+      heading: false,
+      bulletList: bulletList ? undefined : false,
+      orderedList: orderedList ? undefined : false,
+      listItem: bulletList || orderedList ? undefined : false,
+      blockquote: false,
+      code: false,
+      codeBlock: false,
+      horizontalRule: horizontalRule
+        ? {
+            HTMLAttributes: {
+              style: "border-top: 1px solid #E5E7EB; margin: 16px 0;",
+            },
+          }
+        : false,
+      hardBreak: hardBreak ? undefined : false,
+      strike: false,
+    }),
+  );
+
+  return extensions;
+}
+
+export function getAllMentions(content: Content | undefined): Array<Content> {
+  if (!content) return [];
+
+  function processNode(node: Content): Array<Content> {
+    if (typeof node === "string") {
+      return [];
+    }
+
+    if (Array.isArray(node)) {
+      return node.map(processNode);
+    }
+
+    if (!node || typeof node !== "object") {
+      return [];
+    }
+
+    // Process content recursively
+    if (node.content) {
+      const a = node.content.map(processNode);
+      return a.flat();
+    }
+
+    // Handle block-level elements
+    switch (node.type) {
+      case "mention":
+        return [node];
+
+      default:
+        return [];
+    }
+  }
+
+  return (processNode(content)?.flat().filter(Boolean) as Array<Content>) ?? [];
+}
+
+export function extractText(
+  field: JSONContent | string | undefined,
+  renderType: RenderType,
+): string {
+  if (!field) return "";
+
+  // If it's TipTap content (object with type and content)
+  if (typeof field === "object" && field.type) {
+    return generateHtml(field, renderType);
+  }
+
+  // If it's plain text
+  if (typeof field === "string") {
+    return field;
+  }
+
+  return "";
+}
+
+export function isTiptapEmpty(
+  field: JSONContent | string | undefined,
+  renderType: RenderType,
+): boolean {
+  if (!field) return true;
+
+  // For TipTap content
+  if (typeof field === "object" && field.type) {
+    const text = generateText(field, renderType);
+    return !text || text.trim() === "";
+  }
+
+  // For plain text
+  if (typeof field === "string") {
+    return !field || field.trim() === "";
+  }
+
+  return true;
+}
+
+/**
+ * Create TipTap JSON structure from plain text
+ */
+export function createTipTapContent(
+  text: string,
+  options: TipTapExtensionOptions = {
+    preset: "whatsapp",
+    characterLimit: WA_BODY_MAX_LENGTH,
+  },
+) {
+  return generateJSON(text, getTipTapExtensions(options));
+}

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

@@ -0,0 +1,212 @@
+import type {
+  WhatsappMessage,
+  WhatsAppSendPayload,
+  ParameterValidationResult,
+  WhatsappHeaderParam,
+} from "../../types/index.js";
+import type { JSONContent } from "@tiptap/core";
+import { convertToWhatsappMarkdown } from "./whatsapp.js";
+
+/**
+ * Normalize parameters to strings for Meta API compatibility
+ * Handles null, undefined, numbers, booleans, objects
+ */
+export function normalizeParameters(
+  parameters: Record<string, unknown>,
+): Record<string, string> {
+  return Object.fromEntries(
+    Object.entries(parameters).map(([key, value]) => {
+      // Coerce to string
+      if (value === null || value === undefined) return [key, ""];
+      if (typeof value === "string") return [key, value]; // Allow empty strings
+      return [key, String(value)]; // Numbers, booleans, objects
+    }),
+  );
+}
+
+/**
+ * Extract parameter names from text containing {{param_name}} placeholders
+ */
+function extractParameters(text: string): string[] {
+  const paramRegex = /\{\{([^}]+)\}\}/g;
+  const matches = [...text.matchAll(paramRegex)];
+  return matches.map((match) => match[1].trim());
+}
+
+/**
+ * Convert JSONContent to string for parameter extraction
+ */
+function contentToString(content: JSONContent | undefined): string {
+  if (!content) return "";
+  return convertToWhatsappMarkdown(content);
+}
+
+/**
+ * Extract all required parameters from a WhatsApp message template
+ */
+export function extractRequiredParameters(message: WhatsappMessage): string[] {
+  const parameters = new Set<string>();
+
+  // Extract from header if it's text
+  if (message.body.header.type === "text" && message.body.header.content) {
+    const headerText = contentToString(message.body.header.content);
+    extractParameters(headerText).forEach((p) => parameters.add(p));
+  }
+
+  // Extract from body
+  if (message.body.body.content) {
+    const bodyText = contentToString(message.body.body.content);
+    extractParameters(bodyText).forEach((p) => parameters.add(p));
+  }
+
+  // Extract from button URLs
+  if (message.body.buttons.enabled) {
+    message.body.buttons.buttons.forEach((button) => {
+      if (button.type === "link" && button.url) {
+        extractParameters(button.url).forEach((p) => parameters.add(p));
+      }
+    });
+  }
+
+  return Array.from(parameters);
+}
+
+/**
+ * Validate that all required parameters are provided
+ */
+export function validateParameters(
+  message: WhatsappMessage,
+  parameters: Record<string, unknown>,
+): ParameterValidationResult {
+  const required = extractRequiredParameters(message);
+  const provided = Object.keys(parameters);
+
+  const missing = required.filter((p) => !provided.includes(p));
+
+  return {
+    valid: missing.length === 0,
+    required,
+    missing,
+  };
+}
+
+/**
+ * Build component parameters array for Meta API
+ */
+function buildComponentParameters(
+  text: string,
+  parameters: Record<string, string>,
+): Array<{ type: "text"; text: string; parameter_name: string }> {
+  const paramNames = extractParameters(text);
+  return paramNames.map((paramName) => ({
+    type: "text" as const,
+    text: parameters[paramName] ?? "",
+    parameter_name: paramName,
+  }));
+}
+
+/**
+ * Compile WhatsApp message template into Meta Cloud API send format
+ *
+ * @param message - The WhatsApp message template to compile
+ * @param parameters - Key-value pairs for parameter injection (will be normalized to strings)
+ * @returns WhatsApp Cloud API send payload (without 'to' field)
+ */
+export function compileWhatsappTemplate(
+  message: WhatsappMessage,
+  parameters: Record<string, unknown>,
+): Omit<WhatsAppSendPayload, "to"> {
+  // Normalize parameters to strings first
+  const normalizedParams = normalizeParameters(parameters);
+
+  const components: NonNullable<WhatsAppSendPayload["template"]["components"]> =
+    [];
+
+  // Get template name from metadata
+  const templateName = message.metadata?.meta?.template_name;
+  if (!templateName) {
+    throw new Error("Message does not have Meta template name in metadata");
+  }
+
+  // Build header component if exists
+  if (message.body.header.type === "text" && message.body.header.content) {
+    const headerText = contentToString(message.body.header.content);
+    const headerParams = buildComponentParameters(headerText, normalizedParams);
+
+    if (headerParams.length > 0) {
+      components.push({
+        type: "HEADER",
+        parameters: headerParams,
+      });
+    }
+  } else if (
+    (message.body.header.type === "image" ||
+      message.body.header.type === "video" ||
+      message.body.header.type === "document") &&
+    message.body.header.smartchatMediaId
+  ) {
+    const t = message.body.header.type;
+    components.push({
+      type: "HEADER",
+      parameters: [
+        {
+          type: t,
+          [t]: {
+            id: message.body.header.smartchatMediaId,
+          },
+        } as WhatsappHeaderParam,
+      ],
+    });
+  }
+
+  // Build body component (always present if it has parameters)
+  if (message.body.body.content) {
+    const bodyText = contentToString(message.body.body.content);
+    const bodyParams = buildComponentParameters(bodyText, normalizedParams);
+
+    if (bodyParams.length > 0) {
+      components.push({
+        type: "BODY",
+        parameters: bodyParams,
+      });
+    }
+  }
+
+  // Note: Footer doesn't support parameters in Meta API
+
+  // Build button components for URL buttons with parameters
+  if (message.body.buttons.enabled) {
+    message.body.buttons.buttons.forEach((button, index) => {
+      if (button.type === "link" && button.url) {
+        const urlParams = buildComponentParameters(
+          button.url,
+          normalizedParams,
+        );
+        urlParams.forEach((param) => {
+          param.parameter_name = `{{${index + 1}}}`;
+        });
+
+        if (urlParams.length > 0) {
+          components.push({
+            type: "BUTTON",
+            sub_type: "url",
+            index: String(index),
+            parameters: urlParams,
+          });
+        }
+      }
+    });
+  }
+
+  return {
+    messaging_product: "whatsapp",
+    type: "template",
+    template: {
+      name: templateName,
+      language: {
+        code: message.language_id,
+      },
+      components: components.length > 0 ? components : undefined,
+    },
+  };
+}