@capillarytech/creatives-library 8.0.266-alpha.0 → 8.0.266

package/utils/tests/commonUtil.test.js

@@ -1376,228 +1376,4 @@ describe("validateCarouselCards", () => {
       expect(result.isValid).toBe(true);
     });
   });
-
-  describe('extractContent BEE Editor Logic (L404-L412)', () => {
-    it('extracts content from beeHtml as string', () => {
-      const platformData = {
-        title: 'Test Title',
-        isBEEeditor: true,
-        beeHtml: '<p>BEE HTML Content</p>',
-        ctas: [
-          { text: 'Click Here', actionLink: 'https://example.com' },
-        ],
-      };
-
-      const result = extractContent(platformData);
-
-      expect(result).toContain(platformData.title);
-      expect(result).toContain(platformData.beeHtml);
-      expect(result).toContain(platformData.ctas[0].text);
-    });
-
-    it('extracts content from beeHtml as object with value property', () => {
-      const platformData = {
-        title: 'Test Title',
-        isBEEeditor: true,
-        beeHtml: { value: '<p>BEE HTML from Object</p>' },
-        ctas: [
-          { text: 'Button Text' },
-        ],
-      };
-
-      const result = extractContent(platformData);
-
-      expect(result).toContain(platformData.title);
-      expect(result).toContain(platformData.beeHtml.value);
-      expect(result).toContain(platformData.ctas[0].text);
-    });
-
-    it('handles beeHtml as object without value property', () => {
-      const platformData = {
-        title: 'Test Title',
-        isBEEeditor: true,
-        beeHtml: { someOtherProperty: 'data' },
-        ctas: [],
-      };
-
-      const result = extractContent(platformData);
-
-      // Should extract title and empty beeHtml (since value is undefined)
-      expect(result).toContain('Test Title');
-      expect(result).not.toContain('someOtherProperty');
-    });
-
-    it('extracts ctas with text property', () => {
-      const platformData = {
-        title: 'Title',
-        isBEEeditor: true,
-        beeHtml: '<p>Content</p>',
-        ctas: [
-          { text: 'CTA Text 1' },
-          { text: 'CTA Text 2' },
-        ],
-      };
-
-      const result = extractContent(platformData);
-
-      expect(result).toContain('CTA Text 1');
-      expect(result).toContain('CTA Text 2');
-    });
-
-    it('extracts ctas with actionLink when text is missing', () => {
-      const platformData = {
-        title: 'Title',
-        isBEEeditor: true,
-        beeHtml: '<p>Content</p>',
-        ctas: [
-          { actionLink: 'https://link1.com' },
-          { actionLink: 'https://link2.com' },
-        ],
-      };
-
-      const result = extractContent(platformData);
-
-      expect(result).toContain('https://link1.com');
-      expect(result).toContain('https://link2.com');
-    });
-
-    it('filters out falsy values with filter(Boolean)', () => {
-      const platformData = {
-        title: '',
-        isBEEeditor: true,
-        beeHtml: null,
-        ctas: [
-          { text: null, actionLink: null },
-          { text: 'Valid Text' },
-        ],
-      };
-
-      const result = extractContent(platformData);
-
-      // Should only contain 'Valid Text' after filtering
-      expect(result).toBe('Valid Text');
-    });
-
-    it('handles empty ctas array', () => {
-      const platformData = {
-        title: 'Title Only',
-        isBEEeditor: true,
-        beeHtml: '<p>BEE Content</p>',
-        ctas: [],
-      };
-
-      const result = extractContent(platformData);
-
-      expect(result).toContain('Title Only');
-      expect(result).toContain('<p>BEE Content</p>');
-    });
-
-    it('handles undefined ctas', () => {
-      const platformData = {
-        title: 'Title',
-        isBEEeditor: true,
-        beeHtml: '<p>Content</p>',
-        ctas: undefined,
-      };
-
-      const result = extractContent(platformData);
-
-      expect(result).toContain('Title');
-      expect(result).toContain('<p>Content</p>');
-    });
-
-    it('joins all content with spaces', () => {
-      const platformData = {
-        title: 'Title',
-        isBEEeditor: true,
-        beeHtml: 'HTML',
-        ctas: [
-          { text: 'CTA1' },
-          { text: 'CTA2' },
-        ],
-      };
-
-      const result = extractContent(platformData);
-
-      expect(result).toBe('Title HTML CTA1 CTA2');
-    });
-
-    it('falls back to regular content when not BEE editor', () => {
-      const platformData = {
-        title: 'Title',
-        message: 'Message',
-        isBEEeditor: false,
-        beeHtml: '<p>Should be ignored</p>',
-        ctas: [
-          { text: 'CTA' },
-        ],
-      };
-
-      const result = extractContent(platformData);
-
-      expect(result).toContain('Title');
-      expect(result).toContain('Message');
-      expect(result).toContain('CTA');
-      expect(result).not.toContain('<p>Should be ignored</p>');
-    });
-
-    it('handles null beeHtml', () => {
-      const platformData = {
-        title: 'Title',
-        isBEEeditor: true,
-        beeHtml: null,
-        ctas: [{ text: 'CTA' }],
-      };
-
-      const result = extractContent(platformData);
-
-      expect(result).toContain('Title');
-      expect(result).toContain('CTA');
-    });
-
-    it('handles undefined beeHtml', () => {
-      const platformData = {
-        title: 'Title',
-        isBEEeditor: true,
-        beeHtml: undefined,
-        ctas: [],
-      };
-
-      const result = extractContent(platformData);
-
-      expect(result).toBe('Title');
-    });
-
-    it('handles complex ctas with both text and actionLink', () => {
-      const platformData = {
-        title: 'Title',
-        isBEEeditor: true,
-        beeHtml: 'Content',
-        ctas: [
-          { text: 'CTA Text', actionLink: 'https://example.com' },
-        ],
-      };
-
-      const result = extractContent(platformData);
-
-      // Should prefer text over actionLink
-      expect(result).toContain('CTA Text');
-      expect(result).toContain('Title');
-      expect(result).toContain('Content');
-    });
-
-    it('handles empty string beeHtml', () => {
-      const platformData = {
-        title: 'Title',
-        isBEEeditor: true,
-        beeHtml: '',
-        ctas: [{ text: 'CTA' }],
-      };
-
-      const result = extractContent(platformData);
-
-      expect(result).toBe('Title CTA');
-    });
-  });
 });
-

package/utils/tests/transformerUtils.test.js

@@ -15,6 +15,7 @@ import {
   RCS,
   LINE,
   VIBER,
+  WEBPUSH,
 } from "../../v2Containers/CreativesContainer/constants";
 
 describe("transformerUtils", () => {
@@ -1182,6 +1183,302 @@ describe("transformerUtils", () => {
     });
   });
 
+  describe("WebPush payload transformation", () => {
+    it("should transform WebPush data correctly with minimal data", () => {
+      const mockData = {
+        channel: WEBPUSH,
+        messageSubject: "test webpush notification"
+      };
+
+      const result = transformChannelPayload(mockData);
+
+      expect(result.centralCommsPayload).toBeDefined();
+      expect(result.centralCommsPayload.channel).toEqual(WEBPUSH);
+      expect(result.centralCommsPayload.webpushMessageContent.messageSubject).toEqual(
+        "test webpush notification"
+      );
+      expect(result.centralCommsPayload.clientName).toEqual("VENENO");
+    });
+
+    it("should transform WebPush data with all options", () => {
+      const mockData = {
+        channel: WEBPUSH,
+        messageSubject: "test webpush notification",
+        messageContent: {
+          content: {
+            accountId: 12345,
+            content: {
+              title: "WebPush Title",
+              message: "WebPush Message",
+              iconImageUrl: "https://example.com/icon.png",
+              cta: {
+                actionLink: "https://example.com/action",
+                actionText: "Click Here"
+              },
+              expandableDetails: {
+                style: "BIG_TEXT",
+                message: "Expanded Message"
+              }
+            },
+            offers: [
+              { id: "offer-1", title: "Offer 1" },
+              { id: "offer-2", title: "Offer 2" }
+            ]
+          }
+        }
+      };
+
+      const options = {
+        loyaltyMetaData: {
+          actionId: "action-123",
+          ouId: 456,
+          clientName: "TestClient",
+          module: "TestModule",
+          transformedMessageDetails: {
+            webpushDeliverySettings: {
+              sendDate: "2023-01-01",
+              priority: "HIGH"
+            }
+          }
+        }
+      };
+
+      const result = transformChannelPayload(mockData, options);
+
+      // Check base payload
+      expect(result.centralCommsPayload.sourceEntityId).toEqual("action-123");
+      expect(result.centralCommsPayload.ouId).toEqual(456);
+      expect(result.centralCommsPayload.clientName).toEqual("TestClient");
+      expect(result.centralCommsPayload.module).toEqual("TestModule");
+
+      // Check WebPush-specific content
+      expect(result.centralCommsPayload.webpushMessageContent.channel).toEqual(WEBPUSH);
+      expect(result.centralCommsPayload.webpushMessageContent.accountId).toEqual(12345);
+      expect(result.centralCommsPayload.webpushMessageContent.messageSubject).toEqual(
+        "test webpush notification"
+      );
+      expect(result.centralCommsPayload.webpushMessageContent.content.title).toEqual(
+        "WebPush Title"
+      );
+      expect(result.centralCommsPayload.webpushMessageContent.content.message).toEqual(
+        "WebPush Message"
+      );
+      expect(result.centralCommsPayload.webpushMessageContent.content.iconImageUrl).toEqual(
+        "https://example.com/icon.png"
+      );
+      expect(result.centralCommsPayload.webpushMessageContent.content.cta).toEqual({
+        actionLink: "https://example.com/action",
+        actionText: "Click Here"
+      });
+      expect(result.centralCommsPayload.webpushMessageContent.content.expandableDetails).toEqual({
+        style: "BIG_TEXT",
+        message: "Expanded Message"
+      });
+      expect(result.centralCommsPayload.webpushMessageContent.offers).toEqual([
+        { id: "offer-1", title: "Offer 1" },
+        { id: "offer-2", title: "Offer 2" }
+      ]);
+
+      // Check delivery settings
+      expect(result.centralCommsPayload.webpushDeliverySettings).toEqual({
+        sendDate: "2023-01-01",
+        priority: "HIGH"
+      });
+    });
+
+    it("should handle missing messageContent structure", () => {
+      const mockData = {
+        channel: WEBPUSH,
+        messageSubject: "test webpush notification"
+      };
+
+      const result = transformChannelPayload(mockData);
+
+      expect(result.centralCommsPayload.webpushMessageContent.accountId).toEqual(0);
+      expect(result.centralCommsPayload.webpushMessageContent.content.title).toEqual("");
+      expect(result.centralCommsPayload.webpushMessageContent.content.message).toEqual("");
+      expect(result.centralCommsPayload.webpushMessageContent.offers).toEqual([]);
+    });
+
+    it("should handle missing content properties", () => {
+      const mockData = {
+        channel: WEBPUSH,
+        messageSubject: "test webpush notification",
+        messageContent: {
+          content: {
+            accountId: 12345,
+            content: {}
+          }
+        }
+      };
+
+      const result = transformChannelPayload(mockData);
+
+      expect(result.centralCommsPayload.webpushMessageContent.accountId).toEqual(12345);
+      expect(result.centralCommsPayload.webpushMessageContent.content.title).toEqual("");
+      expect(result.centralCommsPayload.webpushMessageContent.content.message).toEqual("");
+      expect(result.centralCommsPayload.webpushMessageContent.content.iconImageUrl).toBeUndefined();
+      expect(result.centralCommsPayload.webpushMessageContent.content.cta).toBeUndefined();
+      expect(result.centralCommsPayload.webpushMessageContent.content.expandableDetails).toBeUndefined();
+    });
+
+    it("should conditionally include iconImageUrl only when present", () => {
+      const mockDataWithoutIcon = {
+        channel: WEBPUSH,
+        messageSubject: "test",
+        messageContent: {
+          content: {
+            content: {
+              title: "Title",
+              message: "Message"
+            }
+          }
+        }
+      };
+
+      const resultWithoutIcon = transformChannelPayload(mockDataWithoutIcon);
+      expect(resultWithoutIcon.centralCommsPayload.webpushMessageContent.content.iconImageUrl).toBeUndefined();
+
+      const mockDataWithIcon = {
+        channel: WEBPUSH,
+        messageSubject: "test",
+        messageContent: {
+          content: {
+            content: {
+              title: "Title",
+              message: "Message",
+              iconImageUrl: "https://example.com/icon.png"
+            }
+          }
+        }
+      };
+
+      const resultWithIcon = transformChannelPayload(mockDataWithIcon);
+      expect(resultWithIcon.centralCommsPayload.webpushMessageContent.content.iconImageUrl).toEqual(
+        "https://example.com/icon.png"
+      );
+    });
+
+    it("should conditionally include cta only when present", () => {
+      const mockDataWithoutCta = {
+        channel: WEBPUSH,
+        messageSubject: "test",
+        messageContent: {
+          content: {
+            content: {
+              title: "Title",
+              message: "Message"
+            }
+          }
+        }
+      };
+
+      const resultWithoutCta = transformChannelPayload(mockDataWithoutCta);
+      expect(resultWithoutCta.centralCommsPayload.webpushMessageContent.content.cta).toBeUndefined();
+
+      const mockDataWithCta = {
+        channel: WEBPUSH,
+        messageSubject: "test",
+        messageContent: {
+          content: {
+            content: {
+              title: "Title",
+              message: "Message",
+              cta: {
+                actionLink: "https://example.com",
+                actionText: "Click"
+              }
+            }
+          }
+        }
+      };
+
+      const resultWithCta = transformChannelPayload(mockDataWithCta);
+      expect(resultWithCta.centralCommsPayload.webpushMessageContent.content.cta).toEqual({
+        actionLink: "https://example.com",
+        actionText: "Click"
+      });
+    });
+
+    it("should conditionally include expandableDetails only when present", () => {
+      const mockDataWithoutExpandable = {
+        channel: WEBPUSH,
+        messageSubject: "test",
+        messageContent: {
+          content: {
+            content: {
+              title: "Title",
+              message: "Message"
+            }
+          }
+        }
+      };
+
+      const resultWithoutExpandable = transformChannelPayload(mockDataWithoutExpandable);
+      expect(resultWithoutExpandable.centralCommsPayload.webpushMessageContent.content.expandableDetails).toBeUndefined();
+
+      const mockDataWithExpandable = {
+        channel: WEBPUSH,
+        messageSubject: "test",
+        messageContent: {
+          content: {
+            content: {
+              title: "Title",
+              message: "Message",
+              expandableDetails: {
+                style: "BIG_TEXT",
+                message: "Expanded"
+              }
+            }
+          }
+        }
+      };
+
+      const resultWithExpandable = transformChannelPayload(mockDataWithExpandable);
+      expect(resultWithExpandable.centralCommsPayload.webpushMessageContent.content.expandableDetails).toEqual({
+        style: "BIG_TEXT",
+        message: "Expanded"
+      });
+    });
+
+    it("should handle undefined webpushDeliverySettings", () => {
+      const mockData = {
+        channel: WEBPUSH,
+        messageSubject: "test webpush notification"
+      };
+
+      const options = {
+        loyaltyMetaData: {
+          transformedMessageDetails: {}
+        }
+      };
+
+      const result = transformChannelPayload(mockData, options);
+
+      expect(result.centralCommsPayload.webpushDeliverySettings).toEqual({});
+    });
+
+    it("should handle empty offers array", () => {
+      const mockData = {
+        channel: WEBPUSH,
+        messageSubject: "test",
+        messageContent: {
+          content: {
+            content: {
+              title: "Title",
+              message: "Message"
+            },
+            offers: []
+          }
+        }
+      };
+
+      const result = transformChannelPayload(mockData);
+
+      expect(result.centralCommsPayload.webpushMessageContent.offers).toEqual([]);
+    });
+  });
+
   describe("getTemplateDiffState", () => {
     it("should return false for unsupported channel", () => {
       const result = getTemplateDiffState("UNSUPPORTED_CHANNEL", {}, {});

package/utils/transformTemplateConfig.js

@@ -101,6 +101,7 @@ export async function transformTemplateConfigWithMediaDetails(templateConfig, ch
   const contentType = detectMediaContentType(templateConfig);
 
   if (contentType === MEDIA_CONTENT_TYPE.NONE) {
+    console.log('No media content detected, returning original config');
     return templateConfig;
   }
 
@@ -108,19 +109,24 @@ export async function transformTemplateConfigWithMediaDetails(templateConfig, ch
   let transformDirection;
   if (forceDirection) {
     transformDirection = forceDirection;
+    console.log(`Forced transformation direction: ${transformDirection}`);
   } else {
     // Auto-detect based on content
     if (contentType === MEDIA_CONTENT_TYPE.URLS) {
       transformDirection = TRANSFORM_DIRECTION.FORWARD; // URLs → tags
+      console.log('Detected URLs, applying forward transformation (URLs → tags)');
     } else if (contentType === MEDIA_CONTENT_TYPE.TAGS) {
       transformDirection = TRANSFORM_DIRECTION.REVERSE; // tags → URLs
+      console.log('Detected media_content tags, applying reverse transformation (tags → URLs)');
     } else if (contentType === MEDIA_CONTENT_TYPE.MIXED) {
       transformDirection = TRANSFORM_DIRECTION.SMART; // Handle mixed content intelligently
+      console.log('Detected mixed content, applying smart transformation');
     }
   }
 
   const newConfig = cloneDeep(templateConfig);
   try {
+    console.log(`Fetching media details for ${transformDirection} transformation, ID: ${mediaDetailsId}`);
 
     // Fetch media details mapping from API
     const response = await getMediaDetails({ id: mediaDetailsId })
@@ -139,6 +145,7 @@ export async function transformTemplateConfigWithMediaDetails(templateConfig, ch
       idToUrlMapping[mediaId] = url;
     });
 
+    console.log(`Processing ${Object.keys(urlToIdMapping).length} media mappings`);
 
     // Apply transformations based on direction
     newConfig?.cards?.forEach(card => {
@@ -150,6 +157,7 @@ export async function transformTemplateConfigWithMediaDetails(templateConfig, ch
           // Forward transformation: URL → tag
           const mediaDetailId = urlToIdMapping[currentUrl];
           if (mediaDetailId) {
+            console.log(`Forward: ${currentUrl} → {{media_content(${mediaDetailId})}}`);
             card.media.url = `{{media_content(${mediaDetailId})}}`;
           } else {
             console.warn(`No media detail ID found for URL: ${currentUrl}`);
@@ -161,6 +169,7 @@ export async function transformTemplateConfigWithMediaDetails(templateConfig, ch
           if (mediaId) {
             const actualUrl = idToUrlMapping[mediaId];
             if (actualUrl) {
+              console.log(`Reverse: {{media_content(${mediaId})}} → ${actualUrl}`);
               card.media.url = actualUrl;
             } else {
               console.warn(`No URL found for media ID: ${mediaId}`);
@@ -176,6 +185,7 @@ export async function transformTemplateConfigWithMediaDetails(templateConfig, ch
     console.error('Failed to fetch media details for transformation:', error);
 
     // Fallback: try to extract/convert what we can without API
+    console.log('Falling back to URL extraction method');
     newConfig.cards.forEach(card => {
       if (card.media && card.media.url) {
         if (transformDirection === TRANSFORM_DIRECTION.FORWARD) {

package/utils/transformerUtils.js

@@ -10,6 +10,7 @@ import {
   RCS,
   LINE,
   VIBER,
+  WEBPUSH,
   EMF,
   VENENO,
   TEXT,
@@ -63,6 +64,8 @@ export const transformChannelPayload = (data, options = {}) => {
       return transformLinePayload(data, options);
     case VIBER:
       return transformViberPayload(data, options);
+    case WEBPUSH:
+      return transformWebpushPayload(data, options);
     default:
       return data; // Return unchanged for unsupported channels
   }
@@ -317,6 +320,43 @@ const transformViberPayload = (viberData, options = {}) => {
   return payload;
 };
 
+/**
+ * Transforms WebPush data to the required payload format
+ * @param {Object} webpushData - Current WebPush data
+ * @param {Object} options - Additional options (ouId, sourceEntityId, etc.)
+ * @returns {Object} - Transformed WebPush payload
+ */
+const transformWebpushPayload = (webpushData, options = {}) => {
+  const { loyaltyMetaData = {} } = options;
+  const { transformedMessageDetails = {} } = loyaltyMetaData;
+  const { webpushDeliverySettings = {} } = transformedMessageDetails || {};
+  
+  // Get base payload structure
+  const payload = createBasePayload(WEBPUSH, loyaltyMetaData);
+  
+  // Extract webpush content from messageContent.content.content structure
+  const webpushContent = webpushData?.messageContent?.content?.content || {};
+  const accountId = webpushData?.messageContent?.content?.accountId || 0;
+  
+  // Add WebPush-specific properties
+  payload.centralCommsPayload.webpushMessageContent = {
+    channel: WEBPUSH,
+    accountId,
+    content: {
+      title: webpushContent?.title || '',
+      message: webpushContent?.message || '',
+      ...(webpushContent?.iconImageUrl && { iconImageUrl: webpushContent.iconImageUrl }),
+      ...(webpushContent?.cta && { cta: webpushContent.cta }),
+      ...(webpushContent?.expandableDetails && { expandableDetails: webpushContent.expandableDetails }),
+    },
+    messageSubject: webpushData?.messageSubject || "",
+    offers: webpushData?.messageContent?.content?.offers || [],
+  };
+  payload.centralCommsPayload.webpushDeliverySettings = webpushDeliverySettings;
+  
+  return payload;
+};
+
 // Checks if the template has changed
 export const getTemplateDiffState = (channel, oldData, newData) => {
   switch (channel.toUpperCase()) {