@capillarytech/creatives-library 9.0.54-alpha.2 → 9.0.54-alpha.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@capillarytech/creatives-library",
   "author": "meharaj",
-  "version": "9.0.54-alpha.2",
+  "version": "9.0.54-alpha.4",
   "description": "Capillary creatives ui",
   "main": "./index.js",
   "module": "./index.es.js",

package/services/api.js

@@ -710,6 +710,17 @@ export const createCommDefinition = (payload) => {
   return request(url, getAPICallObject('POST', payload, false, false, false, true));
 };
 
+// Opens a new DRAFT version with the given content on an EXISTING
+// CommDefinition (same id/referenceId) — used by CommunicationFlow's edit-mode
+// save (re-editing a rejected alert) instead of createCommDefinition, so the
+// alert keeps its identity rather than becoming a brand-new CommDefinition.
+// Route verified against a real Postman sample against Veyron's own
+// /commdefinition/{id}/edit endpoint.
+export const editCommDefinition = (commDefinitionId, payload) => {
+  const url = `${API_ENDPOINT}/comm-definitions/${commDefinitionId}/edit`;
+  return request(url, getAPICallObject('POST', payload, false, false, false, true));
+};
+
 export const getCentralCommsMetaIds = (metaIds, metaType = TRANSACTION) => {
   const url = `${API_ENDPOINT}/common/central-comms/meta-id/${metaType}?metaIds=${metaIds}`;
   return request(url, getAPICallObject('GET', null, false, false, false, true));

package/v2Containers/CommunicationFlow/CommunicationFlow.js

@@ -21,7 +21,7 @@ import CapLabel from '@capillarytech/cap-ui-library/CapLabel';
 // import injectSaga from '../../utils/injectSaga';   // cap-coupons flows disabled
 // import injectReducer from '../../utils/injectReducer';
 import { makeSelectAuthenticated } from '../Cap/selectors';
-import { createCommDefinition } from '../../services/api';
+import { createCommDefinition, editCommDefinition } from '../../services/api';
 import DynamicControlsStep from './steps/DynamicControlsStep';
 import MessageTypeStep from './steps/MessageTypeStep';
 import CommunicationStrategyStep from './steps/CommunicationStrategyStep';
@@ -215,14 +215,29 @@ const CommunicationFlow = ({
           singleChannelStrategy: {
             variant: {
               channel,
-              ...(contentKey && { [contentKey]: { channel, ...contentPayload } }),
-              ...(deliveryKey && { [deliveryKey]: { channelSettings: { channel, ...channelSettings } } }),
+              // `channel` spreads LAST in both objects below — contentItem.templateData
+              // (e.g. mobile push) carries the UI's own internal channel identifier
+              // (MOBILEPUSH), which must never win over CCS's normalized enum value
+              // (PUSH) once spread order puts it after.
+              ...(contentKey && { [contentKey]: { ...contentPayload, channel } }),
+              ...(deliveryKey && { [deliveryKey]: { channelSettings: { ...channelSettings, channel } } }),
             },
           },
         };
 
+        // Editing an existing (e.g. rejected) alert: config.context.existingCommDefinitionId
+        // opens a new DRAFT version on that SAME CommDefinition instead of creating a
+        // brand-new one, so the alert keeps its id/referenceId across the edit.
+        const { existingCommDefinitionId } = config?.context || {};
+
         try {
-          const res = await createCommDefinition(payload);
+          const res = existingCommDefinitionId
+            ? await editCommDefinition(existingCommDefinitionId, {
+              strategyType: payload.strategyType,
+              settings: payload.settings,
+              singleChannelStrategy: payload.singleChannelStrategy,
+            })
+            : await createCommDefinition(payload);
           if (isDuplicateReferenceIdError(res)) {
             // Duplicate referenceId in this org — block the save so the user can
             // change it, rather than silently proceeding without a CCS comm.
@@ -230,7 +245,16 @@ const CommunicationFlow = ({
             return;
           }
           const data = res?.response?.data;
-          if (data?.id) {
+          if (existingCommDefinitionId) {
+            if (data) {
+              ccsCommDefinition = {
+                id: existingCommDefinitionId,
+                referenceId: referenceId || data.referenceId,
+                version: data.version?.version ?? data.version ?? 1,
+                status: data.status,
+              };
+            }
+          } else if (data?.id) {
             ccsCommDefinition = {
               id: data.id,
               referenceId: data.referenceId,

package/v2Containers/CommunicationFlow/CommunicationFlowCard.js

@@ -42,7 +42,7 @@ const resolveValue = (val) => {
 
 const SENDER_ID_RESOLVERS = {
   [SMS]: (setting) => resolveValue(setting?.gsmSenderId),
-  [EMAIL]: (setting) => resolveValue(setting?.senderEmail),
+  [EMAIL]: (setting) => resolveValue(setting?.senderId),
   [VIBER]: (setting) => resolveValue(setting?.sender) || resolveValue(setting?.gsmSenderId),
   [WHATSAPP]: (setting) => resolveValue(setting?.senderMobNum),
   [RCS]: (setting) => resolveValue(setting?.senderMobNum) || resolveValue(setting?.rcsSender),

package/v2Containers/CommunicationFlow/Tests/CommunicationFlow.test.js

@@ -2,6 +2,7 @@ import React from 'react';
 
 jest.mock('../../../services/api', () => ({
   createCommDefinition: jest.fn(),
+  editCommDefinition: jest.fn(),
 }));
 
 jest.mock('../../CreativesContainer', () => function MockCreativesContainer({
@@ -37,7 +38,7 @@ import { IntlProvider } from 'react-intl';
 import history from '../../../utils/history';
 import { initialReducer } from '../../../initialReducer';
 import CommunicationFlow from '../CommunicationFlow';
-import { createCommDefinition } from '../../../services/api';
+import { createCommDefinition, editCommDefinition } from '../../../services/api';
 import { getEnabledSteps } from '../utils/getEnabledSteps';
 import {
   CHANNELS,
@@ -407,7 +408,7 @@ describe('handleSave — CCS flow', () => {
       initialData: {
         contentItems: [{
           channel: 'EMAIL',
-          templateData: { emailSubject: 'Order Confirmed', messageBody: '<html>Hi</html>' },
+          templateData: { emailSubject: 'Order Confirmed', emailBody: '<html>Hi</html>' },
         }],
       },
       onSave,
@@ -478,13 +479,21 @@ describe('handleSave — CCS flow', () => {
     );
   });
 
-  it('normalizes the internal MOBILEPUSH channel to CCS\'s PUSH enum (keys stay mpush*)', async () => {
+  it('normalizes the internal MOBILEPUSH channel to CCS\'s PUSH enum (keys stay mpush*), even when templateData/channelSetting carry their own stray channel field', async () => {
     const onSave = jest.fn();
     renderWithFlow({
       features: {},
       config: ccsConfig,
       initialData: {
-        contentItems: [{ channel: 'MOBILEPUSH', templateData: { messageSubject: 'Hi' } }],
+        // `channel: 'MOBILEPUSH'` inline on templateData reproduces the real
+        // production bug: contentItem.templateData carries the UI's own
+        // internal channel identifier, which must not win over the
+        // normalized 'PUSH' enum once spread into mpushMessageContent.
+        contentItems: [{ channel: 'MOBILEPUSH', templateData: { channel: 'MOBILEPUSH', messageSubject: 'Hi' } }],
+        // Likewise, deliverySetting.channelSetting.PUSH carrying its own
+        // stray `channel` key must not win over the normalized value once
+        // spread into mpushDeliverySettings.channelSettings.
+        deliverySetting: { channelSetting: { PUSH: { channel: 'MOBILEPUSH', domainId: 2002 } } },
       },
       onSave,
     });
@@ -498,6 +507,9 @@ describe('handleSave — CCS flow', () => {
           variant: expect.objectContaining({
             channel: 'PUSH',
             mpushMessageContent: { channel: 'PUSH', messageSubject: 'Hi' },
+            mpushDeliverySettings: {
+              channelSettings: { channel: 'PUSH', domainId: 2002 },
+            },
           }),
         }),
       }),
@@ -727,6 +739,86 @@ describe('handleSave — CCS flow', () => {
       gsmSenderId: 'BRAND1',
     });
   });
+
+  it('does not call editCommDefinition when config.context.existingCommDefinitionId is absent', async () => {
+    const onSave = jest.fn();
+    renderWithFlow({
+      features: {},
+      config: ccsConfig,
+      initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
+      onSave,
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(createCommDefinition).toHaveBeenCalledTimes(1));
+    expect(editCommDefinition).not.toHaveBeenCalled();
+  });
+
+  it('calls editCommDefinition (not createCommDefinition) and merges the existing id into ccsCommDefinition when config.context.existingCommDefinitionId is set', async () => {
+    editCommDefinition.mockResolvedValue({
+      response: { data: { version: { version: 2 }, status: 'DRAFT' } },
+    });
+    const onSave = jest.fn();
+    renderWithFlow({
+      features: {},
+      config: {
+        ...ccsConfig,
+        context: { ...ccsConfig.context, referenceId: 'ORDER_PLACED', existingCommDefinitionId: 'cd_existing_1' },
+      },
+      initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
+      onSave,
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(editCommDefinition).toHaveBeenCalledTimes(1));
+    expect(editCommDefinition).toHaveBeenCalledWith(
+      'cd_existing_1',
+      expect.objectContaining({
+        strategyType: 'SINGLE',
+        settings: expect.anything(),
+        singleChannelStrategy: expect.anything(),
+      }),
+    );
+    expect(createCommDefinition).not.toHaveBeenCalled();
+
+    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
+    expect(onSave).toHaveBeenCalledWith(
+      expect.objectContaining({
+        ccsCommDefinition: {
+          id: 'cd_existing_1',
+          referenceId: 'ORDER_PLACED',
+          version: 2,
+          status: 'DRAFT',
+        },
+      }),
+    );
+  });
+
+  it('blocks save and shows an error when editCommDefinition resolves with a duplicate REFERENCE_ID_EXISTS conflict', async () => {
+    editCommDefinition.mockResolvedValue({
+      success: false,
+      status: { isError: true, code: 409, message: 'REFERENCE_ID_EXISTS' },
+      message: 'REFERENCE_ID_EXISTS',
+    });
+    const onSave = jest.fn();
+    renderWithFlow({
+      features: {},
+      config: {
+        ...ccsConfig,
+        context: { ...ccsConfig.context, referenceId: 'ORDER_PLACED', existingCommDefinitionId: 'cd_existing_1' },
+      },
+      initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
+      onSave,
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(editCommDefinition).toHaveBeenCalledTimes(1));
+    expect(await screen.findByText(/already in use in your organization/i)).toBeInTheDocument();
+    expect(onSave).not.toHaveBeenCalled();
+  });
 });
 
 describe('renderSteps — null returns and edge cases', () => {

package/v2Containers/CommunicationFlow/Tests/CommunicationFlowCard.test.js

@@ -247,11 +247,11 @@ describe('CommunicationFlowCard', () => {
       expect(screen.getByText(/Sender ID/)).toBeInTheDocument();
     });
 
-    it('shows senderEmail for EMAIL with Sender ID label', () => {
+    it('shows senderId for EMAIL with Sender ID label', () => {
       renderCard({
         initialData: makeSavedData({
           contentItems: [{ channel: 'EMAIL', templateData: {} }],
-          deliverySetting: { channelSetting: { EMAIL: { senderEmail: 'test@example.com' } } },
+          deliverySetting: { channelSetting: { EMAIL: { senderId: 'test@example.com' } } },
         }),
       });
       expect(screen.getByText(/test@example.com/)).toBeInTheDocument();

package/v2Containers/CommunicationFlow/constants.js

@@ -68,14 +68,15 @@ export const CCS_CHANNEL_CONTENT_KEY_MAP = {
 // editor (messageMeta-oriented field names) — for channels whose legacy field
 // names don't match CCS's own content schema, transform before sending rather
 // than dumping templateData as-is. EMAIL: legacy stores the subject as
-// `emailSubject` (see getContentBody.js), CCS expects `messageSubject`;
-// `messageBody` already matches CCS's name by coincidence. Channels absent
-// here are passed through unchanged (their legacy/CCS field names already
-// align, e.g. SMS's `message`/`messageBody`).
+// `emailSubject` and the HTML body as `emailBody` (see
+// extractContentForPreview.js and CreativesContainer/index.js, where the Bee
+// editor's output is written back into templateData.emailBody — also
+// mirrored by the existing legacy emailMessageContent builder in
+// utils/transformerUtils.js). CCS expects `messageSubject`/`messageBody`.
 export const CCS_CONTENT_TRANSFORMS = {
   EMAIL: (templateData = {}) => ({
     messageSubject: templateData.emailSubject,
-    messageBody: templateData.messageBody,
+    messageBody: templateData.emailBody || templateData.emailHtml,
   }),
   // WEBPUSH: the legacy editor nests the real data under
   // messageContent.content (see CommunicationFlowCard.js's own comment on

package/v2Containers/CommunicationFlow/steps/DeliverySettingsStep/SenderDetails.js

@@ -29,6 +29,7 @@ import {
   getEmailDefaultsForDomainId,
   getSmsDefaultsForDomainId,
   getRcsAccountName,
+  getEmailDomainGatewayMapIdByDomainId,
 } from './deliverySettingsConfig';
 import messages from '../../messages';
 import './SenderDetails.scss';
@@ -151,6 +152,11 @@ const SenderDetails = ({
           saveValues.whatsappDomainId = matchedDomain?.domainProperties?.id ?? matchedDomain?.domainId ?? matchedDomain?.id;
         }
       }
+      // Include EMAIL domainGatewayMapId derived from the selected domain for persistence -
+      // CCS needs it alongside domainId, but it's not a user-facing field.
+      if (entity && fieldValues.emailDomain != null && fieldValues.emailDomain !== '') {
+        saveValues.emailDomainGatewayMapId = getEmailDomainGatewayMapIdByDomainId(entity, fieldValues.emailDomain);
+      }
       onSave(saveValues);
     }
     onClose();

package/v2Containers/CommunicationFlow/steps/DeliverySettingsStep/Tests/SenderDetails.test.js

@@ -83,6 +83,7 @@ const ENTITIES = {
   emailTwoDomains: {
     EMAIL: [
       {
+        id: 'gwmap-a',
         domainProperties: {
           id: 'em-a',
           domainName: 'Mail Alpha',
@@ -101,6 +102,7 @@ const ENTITIES = {
         },
       },
       {
+        id: 'gwmap-b',
         domainProperties: {
           id: 'em-b',
           domainName: 'Mail Beta',
@@ -322,6 +324,29 @@ describe('SenderDetails', () => {
     });
   });
 
+  it('persists emailDomainGatewayMapId derived from the selected email domain on save', async () => {
+    const { onSave } = renderSenderDetails({
+      channels: ['EMAIL'],
+      preloadedDomainProperties: ENTITIES.emailTwoDomains,
+    });
+    const root = document.querySelector('.sender-details');
+    await waitFor(() => expect(within(root).getByText('Mail Alpha')).toBeInTheDocument());
+
+    await openSelectAndChoose(root, 0, 'Mail Beta');
+    await waitFor(() => expect(within(root).getByText('beta@other.com')).toBeInTheDocument());
+
+    const saveBtn = within(root).getByRole('button', { name: /save changes/i });
+    await waitFor(() => expect(saveBtn).not.toBeDisabled());
+    fireEvent.click(saveBtn);
+
+    expect(onSave).toHaveBeenCalledWith(
+      expect.objectContaining({
+        emailDomain: 'em-b',
+        emailDomainGatewayMapId: 'gwmap-b',
+      }),
+    );
+  });
+
   it('resets email domain row back to the first gateway', async () => {
     renderSenderDetails({
       channels: ['EMAIL'],

package/v2Containers/CommunicationFlow/steps/DeliverySettingsStep/Tests/deliverySettingsConfig.test.js

@@ -438,6 +438,7 @@ describe('deliverySettingsConfig — user-facing flows', () => {
         smsDomain: 'd1',
         smsSenderId: 'g1',
         emailDomain: 'ed',
+        emailDomainGatewayMapId: 'gwmap-1',
         emailSenderId: 'mail@x.com',
         emailSenderName: 'N',
         emailReplyToId: 'r@x.com',
@@ -455,9 +456,10 @@ describe('deliverySettingsConfig — user-facing flows', () => {
         SMS: { domainId: 'd1', gsmSenderId: 'g1' },
         EMAIL: {
           domainId: 'ed',
-          senderEmail: 'mail@x.com',
+          domainGatewayMapId: 'gwmap-1',
+          senderId: 'mail@x.com',
           senderLabel: 'N',
-          senderReplyTo: 'r@x.com',
+          replyToId: 'r@x.com',
         },
         WHATSAPP: { domainId: 'wd', senderMobNum: '+w' },
         RCS: { senderMobNum: '+r', rcsSender: '+r' },
@@ -472,9 +474,10 @@ describe('deliverySettingsConfig — user-facing flows', () => {
         SMS: { domainId: 'd', gsmSenderId: 'g' },
         EMAIL: {
           domainId: 'ed',
-          senderEmail: 'e@e.com',
+          domainGatewayMapId: 'gwmap-2',
+          senderId: 'e@e.com',
           senderLabel: 'L',
-          senderReplyTo: 'r@e.com',
+          replyToId: 'r@e.com',
         },
         WHATSAPP: { senderMobNum: '+w', domainId: 'wid' },
         RCS: { rcsSender: '+r' },
@@ -486,6 +489,10 @@ describe('deliverySettingsConfig — user-facing flows', () => {
         smsDomain: 'd',
         smsSenderId: 'g',
         emailDomain: 'ed',
+        emailDomainGatewayMapId: 'gwmap-2',
+        emailSenderId: 'e@e.com',
+        emailSenderName: 'L',
+        emailReplyToId: 'r@e.com',
         whatsappDomainId: 'wid',
         viberSenderId: 'vx',
       });

package/v2Containers/CommunicationFlow/steps/DeliverySettingsStep/deliverySettingsConfig.js

@@ -181,6 +181,14 @@ const getEmailDomainValue = (entity) => {
   return emailData.domainProperties?.id ?? emailData.domainId ?? emailData.id ?? '';
 };
 
+// CCS's domainGatewayMapId is the domainProperties API's own outer `id`
+// (distinct from `domainProperties.id`, which is the numeric domainId) - the
+// domain-gateway-mapping id for the selected domain entry.
+const getEmailDomainGatewayMapIdByDomainId = (entity, domainId) => {
+  const domainEntry = getEmailDomainById(entity, domainId);
+  return domainEntry?.id ?? '';
+};
+
 /** Domain name for summary display (parseEntityForDisplay) */
 const getEmailDomainNameForDisplay = (entity) => {
   const emailData = getEmailData(entity);
@@ -262,6 +270,8 @@ const getEmailDefaultsForDomain = (domainData) => {
  * context.fieldValues has current form state (e.g. selected emailDomain)
  * Aligned with adiona-ui/cap-campaigns-v2: default = contactInfo item with default:true, or first
  */
+export { getEmailDomainGatewayMapIdByDomainId };
+
 export const getDefaultValueForField = (fieldKey, entity, context = {}) => {
   if (!entity) return '';
   const fieldValues = context?.fieldValues || {};
@@ -574,7 +584,11 @@ export const parseEntityForDisplay = (entity, context = {}) => {
     senderDetails: entity,
     smsSenderId: getSmsSenderIdValue(entity),
     smsDomain: getSmsDomainValue(entity),
+    // emailDomain here is the domain NAME (for display only) - buildChannelSettingFromFieldValues
+    // needs the numeric domainId/domainGatewayMapId, sourced separately below.
     emailDomain: getEmailDomainNameForDisplay(entity),
+    emailDomainId: getEmailDomainValue(entity),
+    emailDomainGatewayMapId: getEmailDomainGatewayMapIdByDomainId(entity, getEmailDomainValue(entity)),
     emailSenderId: getEmailSenderIdValue(entity),
     viberSenderId: getSenderIdFromContactInfo(entity, 'VIBER'),
     zaloSenderId: getSenderIdFromContactInfo(entity, 'ZALO'),
@@ -600,10 +614,14 @@ export const buildChannelSettingFromFieldValues = (fieldValues = {}) => {
   }
   if (fieldValues.emailDomain != null || fieldValues.emailSenderId != null || fieldValues.emailSenderName != null || fieldValues.emailReplyToId != null) {
     channelSetting.EMAIL = {
-      domainId: fieldValues.emailDomain,
-      senderEmail: fieldValues.emailSenderId,
+      // emailDomainId (numeric, from the auto-save-defaults path via parseEntityForDisplay)
+      // takes priority over emailDomain, which is numeric when sourced from SenderDetails'
+      // own field state but a display NAME string when sourced from parseEntityForDisplay.
+      domainId: fieldValues.emailDomainId ?? fieldValues.emailDomain,
+      domainGatewayMapId: fieldValues.emailDomainGatewayMapId,
+      senderId: fieldValues.emailSenderId,
       senderLabel: fieldValues.emailSenderName,
-      senderReplyTo: fieldValues.emailReplyToId,
+      replyToId: fieldValues.emailReplyToId,
     };
   }
   if (fieldValues.whatsappSenderNumber != null || fieldValues.whatsappAccount != null) {
@@ -673,9 +691,10 @@ export const parseChannelSettingForDisplay = (channelSetting = {}) => {
   }
   if (channelSetting.EMAIL) {
     out.emailDomain = channelSetting.EMAIL.domainId;
-    out.emailSenderId = channelSetting.EMAIL.senderEmail;
+    out.emailDomainGatewayMapId = channelSetting.EMAIL.domainGatewayMapId;
+    out.emailSenderId = channelSetting.EMAIL.senderId;
     out.emailSenderName = channelSetting.EMAIL.senderLabel;
-    out.emailReplyToId = channelSetting.EMAIL.senderReplyTo;
+    out.emailReplyToId = channelSetting.EMAIL.replyToId;
   }
   if (channelSetting.WHATSAPP) {
     out.whatsappSenderNumber = channelSetting.WHATSAPP.senderMobNum;