@capillarytech/creatives-library 9.0.52 → 9.0.53-alpha.1

package/constants/unified.js

@@ -63,7 +63,6 @@ export const ENABLE_AI_SUGGESTIONS = 'ENABLE_AI_SUGGESTIONS';
 export const AI_CONTENT_BOT_DISABLED = 'AI_CONTENT_BOT_DISABLED';
 export const AI_DOCUMENTATION_BOT_ENABLED = 'AI_DOCUMENTATION_BOT_ENABLED';
 export const ENABLE_PRODUCT_SUPPORT_VIDEOS = 'ENABLE_PRODUCT_SUPPORT_VIDEOS';
-export const SUPPORT_ENGAGEMENT_MODULE = 'SUPPORT_ENGAGEMENT_MODULE';
 export const EMBEDDED = 'embedded';
 // --- Tag/Validation Constants ---
 export const CARD_RELATED_TAGS = [

package/package.json

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

package/services/api.js

@@ -701,6 +701,15 @@ export const createCentralCommsMetaId = (payload, metaType = TRANSACTION) => {
   return request(url, getAPICallObject('POST', payload, false, false, false, true));
 };
 
+// CCS CommDefinition API (new Veyron /api/v1/commdefinition surface, proxied
+// through cap-creatives-api's /comm-definitions). Used by CommunicationFlow's
+// own Save action — separate from the legacy messageMeta functions above,
+// which remain in use by CreativesContainer's own save flow (Cap/sagas.js).
+export const createCommDefinition = (payload) => {
+  const url = `${API_ENDPOINT}/comm-definitions`;
+  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/utils/common.js

@@ -99,10 +99,6 @@ export const hasSupportCKEditor = Auth.hasFeatureAccess.bind(
   null,
   SUPPORT_CK_EDITOR,
 );
-export const hasSupportEngagementModule = Auth.hasFeatureAccess.bind(
-  null,
-  SUPPORT_ENGAGEMENT_MODULE,
-);
 
 export const hasGiftVoucherFeature = Auth.hasFeatureAccess.bind(
   null,

package/v2Containers/CommunicationFlow/CommunicationFlow.js

@@ -17,10 +17,11 @@ import { createStructuredSelector } from 'reselect';
 import CapRow from '@capillarytech/cap-ui-library/CapRow';
 import CapDivider from '@capillarytech/cap-ui-library/CapDivider';
 import CapButton from '@capillarytech/cap-ui-library/CapButton';
+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 { createCentralCommsMetaId, getCentralCommsMetaIds } from '../../services/api';
+import { createCommDefinition } from '../../services/api';
 import DynamicControlsStep from './steps/DynamicControlsStep';
 import MessageTypeStep from './steps/MessageTypeStep';
 import CommunicationStrategyStep from './steps/CommunicationStrategyStep';
@@ -35,9 +36,10 @@ import {
   CHANNELS,
   INCENTIVE_TYPES,
   DYNAMIC_CONTROLS_CONFIG,
-  CHANNEL_CONTENT_KEY_MAP,
-  CHANNEL_DELIVERY_KEY_MAP,
-  CAMPAIGNS,
+  CCS_STRATEGY_TYPE_SINGLE,
+  CCS_CHANNEL_CONTENT_KEY_MAP,
+  CCS_CHANNEL_DELIVERY_KEY_MAP,
+  CCS_CHANNEL_NAME_MAP,
 } from './constants';
 import { getEnabledSteps } from './utils/getEnabledSteps';
 import messages from './messages';
@@ -64,6 +66,25 @@ const hasDeliverySettingForChannel = (channelSetting, channel) => {
   return !!settings && Object.values(settings).some((v) => v !== null && v !== '' && v !== undefined);
 };
 
+// createCommDefinition resolves (rather than rejects) with the CCS error envelope
+// for 4xx/5xx responses — see api.js's request()/checkStatus. A duplicate
+// referenceId within the org comes back as this specific 409.
+const isDuplicateReferenceIdError = (res) => res?.success === false && res?.status?.message === 'REFERENCE_ID_EXISTS';
+
+/**
+ * CCS requires referenceId on create; the consumer-supplied Alert/comm name is
+ * mandatory but referenceId is optional in every consumer's own form. Generate
+ * a stable fallback from the name rather than failing the save.
+ */
+const buildCcsReferenceId = (name) => {
+  const slug = (name || 'COMM')
+    .trim()
+    .toUpperCase()
+    .replace(/[^A-Z0-9]+/g, '_')
+    .replace(/^_+|_+$/g, '') || 'COMM';
+  return `${slug}_${Date.now()}`;
+};
+
 const CommunicationFlow = ({
   config,
   initialData,
@@ -91,6 +112,7 @@ const CommunicationFlow = ({
     };
   });
   const [validationErrors, setValidationErrors] = useState({});
+  const [saveError, setSaveError] = useState(null);
 
   // Memoize enabled steps
   const enabledSteps = useMemo(() => getEnabledSteps(config), [config]);
@@ -150,74 +172,78 @@ const CommunicationFlow = ({
   }, []);
 
   const handleSave = useCallback(async () => {
+    setSaveError(null);
     const aggregatedData = getAggregatedData();
     const shouldUseCCS = config?.useCCS !== false;
+    let ccsCommDefinition = null;
 
     if (shouldUseCCS) {
-      const ouId = config?.context?.ouId || -1;
-      const module = config?.context?.module
-        || (config?.consumer ? config.consumer.toUpperCase() : CAMPAIGNS);
+      const isMultiChannel = [CHANNEL_PRIORITY, AB_TEST].includes(aggregatedData.communicationStrategy);
+      const contentItem = (aggregatedData.contentItems || [])[0];
+      // Consumer-supplied name (e.g. CapNotify's Alert Name field) — CommunicationFlow
+      // has no name input of its own, so this is mandatory input from config.context.
+      const name = config?.context?.name;
 
-      const channelContentKeyMap = CHANNEL_CONTENT_KEY_MAP;
-      const channelDeliveryKeyMap = CHANNEL_DELIVERY_KEY_MAP;
+      // CCS create is SINGLE-strategy only this phase (D1); CHANNEL_PRIORITY/AB_TEST
+      // carry multiple content items with no CCS equivalent yet.
+      if (!isMultiChannel && contentItem && name) {
+        const rawChannel = (contentItem.channel || '').toUpperCase();
+        const channel = CCS_CHANNEL_NAME_MAP[rawChannel] || rawChannel;
+        const contentKey = CCS_CHANNEL_CONTENT_KEY_MAP[channel];
+        const deliveryKey = CCS_CHANNEL_DELIVERY_KEY_MAP[channel];
+        const { dynamicControls = {} } = aggregatedData;
+        const channelSettings = aggregatedData.deliverySetting?.channelSetting?.[channel] || {};
+        const referenceId = config?.context?.referenceId || buildCcsReferenceId(name);
 
-      const contentItems = aggregatedData.contentItems || [];
-      const { dynamicControls = {} } = aggregatedData;
+        const payload = {
+          referenceId,
+          name,
+          description: config?.context?.description || undefined,
+          strategyType: CCS_STRATEGY_TYPE_SINGLE,
+          settings: {
+            additionalSettings: {
+              useTinyUrl: dynamicControls.useTinyUrl ?? false,
+              encryptUrl: dynamicControls.sendToControlCustomers ?? false,
+              linkTrackingEnabled: dynamicControls.overrideDailyLimit ?? false,
+              userSubscriptionDisabled: dynamicControls.sendToBrandPocs ?? false,
+            },
+            executionParams: {},
+          },
+          singleChannelStrategy: {
+            variant: {
+              channel,
+              ...(contentKey && { [contentKey]: contentItem.templateData }),
+              ...(deliveryKey && { [deliveryKey]: { channelSettings: { channel, ...channelSettings } } }),
+            },
+          },
+        };
 
-      const additionalSettings = {
-        useTinyUrl: dynamicControls.useTinyUrl ?? false,
-        encryptUrl: dynamicControls.sendToControlCustomers ?? false,
-        linkTrackingEnabled: dynamicControls.overrideDailyLimit ?? false,
-        userSubscriptionDisabled: dynamicControls.sendToBrandPocs ?? false,
-      };
-
-      if (contentItems.length > 0) {
         try {
-          const responses = await Promise.all(
-            contentItems.map((item) => {
-              const channel = (item.channel || '').toUpperCase();
-              const contentKey = channelContentKeyMap[channel];
-              const deliveryKey = channelDeliveryKeyMap[channel];
-              const payload = {
-                centralCommsPayload: {
-                  ouId,
-                  channel,
-                  module,
-                  executionParams: {},
-                  clientName: 'EMF',
-                  ...(contentKey && {
-                    [contentKey]: { channel, ...item.templateData },
-                  }),
-                  ...(deliveryKey && {
-                    [deliveryKey]: {
-                      additionalSettings,
-                      channelSettings: {
-                        channel,
-                        ...(aggregatedData.deliverySetting?.channelSetting?.[channel] || {}),
-                      },
-                    },
-                  }),
-                },
-              };
-              return createCentralCommsMetaId(payload);
-            }),
-          );
-
-          const metaIds = responses
-            .map((res) => res?.response?.data?.id)
-            .filter(Boolean)
-            .join(',');
-
-          if (metaIds) {
-            const getResponse = await getCentralCommsMetaIds(metaIds);
+          const res = 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.
+            setSaveError(formatMessage(messages.duplicateReferenceIdError));
+            return;
+          }
+          const data = res?.response?.data;
+          if (data?.id) {
+            ccsCommDefinition = {
+              id: data.id,
+              referenceId: data.referenceId,
+              version: data.version?.version || 1,
+              status: data.status,
+            };
           }
         } catch (error) {
-          console.error('[CommunicationFlow] CCS createCentralCommsMetaId error:', error);
+          console.error('[CommunicationFlow] CCS createCommDefinition error:', error);
         }
+      } else if (!name) {
+        console.warn('[CommunicationFlow] Skipping CCS createCommDefinition — config.context.name is required');
       }
     }
 
-    onSave(aggregatedData);
+    onSave(ccsCommDefinition ? { ...aggregatedData, ccsCommDefinition } : aggregatedData);
   }, [getAggregatedData, config, onSave]);
 
   // Call onChange callback when stepData changes
@@ -317,6 +343,11 @@ const CommunicationFlow = ({
       {renderSteps()}
       {onSave && (
         <CapRow useLegacy className="communication-flow-container__footer">
+          {saveError && (
+            <CapLabel type="label2" className="communication-flow-container__save-error">
+              {saveError}
+            </CapLabel>
+          )}
           <CapButton type="primary" onClick={handleSave} disabled={isSaveDisabled}>
             {formatMessage(messages.save)}
           </CapButton>

package/v2Containers/CommunicationFlow/CommunicationFlowCard.js

@@ -19,6 +19,7 @@ import CapIcon from '@capillarytech/cap-ui-library/CapIcon';
 import CapLabel from '@capillarytech/cap-ui-library/CapLabel';
 import CapHeader from '@capillarytech/cap-ui-library/CapHeader';
 import CapSlideBox from '@capillarytech/cap-ui-library/CapSlideBox';
+import CapTooltip from '@capillarytech/cap-ui-library/CapTooltip';
 import CommunicationFlow from './index';
 import { CHANNELS, DEFAULT_COMMUNICATION_STRATEGY_OPTIONS, DYNAMIC_CONTROLS_CONFIG } from './constants';
 import {
@@ -74,6 +75,8 @@ const CommunicationFlowCard = ({
   onChange,
   cap,
   intl,
+  disabled,
+  disabledTooltip,
 }) => {
   const { formatMessage } = intl || {};
   const [showSlideBox, setShowSlideBox] = useState(false);
@@ -91,8 +94,9 @@ const CommunicationFlowCard = ({
   }, [onCancel]);
 
   const handleOpen = useCallback(() => {
+    if (disabled) return;
     setShowSlideBox(true);
-  }, []);
+  }, [disabled]);
 
   const firstItem = savedData?.contentItems?.[0];
   const channelConfig = firstItem
@@ -182,9 +186,17 @@ const CommunicationFlowCard = ({
               <CapImage src={addCreativesIllustration} />
             </CapColumn>
             <CapColumn span={14} className="empty-card-action-col">
-              <CapButton type="secondary" onClick={handleOpen}>
-                {formatMessage(messages.addCreatives)}
-              </CapButton>
+              {disabled && disabledTooltip ? (
+                <CapTooltip title={disabledTooltip}>
+                  <CapButton type="secondary" disabled>
+                    {formatMessage(messages.addCreatives)}
+                  </CapButton>
+                </CapTooltip>
+              ) : (
+                <CapButton type="secondary" onClick={handleOpen} disabled={disabled}>
+                  {formatMessage(messages.addCreatives)}
+                </CapButton>
+              )}
             </CapColumn>
           </CapRow>
         </CapCard>
@@ -227,6 +239,8 @@ CommunicationFlowCard.propTypes = {
   onChange: PropTypes.func,
   cap: PropTypes.object,
   intl: PropTypes.object.isRequired,
+  disabled: PropTypes.bool, // Disables the "Add creatives" trigger (e.g. until a consumer-required field is filled)
+  disabledTooltip: PropTypes.node, // Shown on hover when disabled is true
 };
 
 CommunicationFlowCard.defaultProps = {
@@ -235,6 +249,8 @@ CommunicationFlowCard.defaultProps = {
   onCancel: null,
   onChange: null,
   cap: null,
+  disabled: false,
+  disabledTooltip: null,
 };
 
 export default injectIntl(CommunicationFlowCard);

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

@@ -1,8 +1,7 @@
 import React from 'react';
 
 jest.mock('../../../services/api', () => ({
-  createCentralCommsMetaId: jest.fn(),
-  getCentralCommsMetaIds: jest.fn(),
+  createCommDefinition: jest.fn(),
 }));
 
 jest.mock('../../CreativesContainer', () => function MockCreativesContainer({
@@ -38,7 +37,7 @@ import { IntlProvider } from 'react-intl';
 import history from '../../../utils/history';
 import { initialReducer } from '../../../initialReducer';
 import CommunicationFlow from '../CommunicationFlow';
-import { createCentralCommsMetaId, getCentralCommsMetaIds } from '../../../services/api';
+import { createCommDefinition } from '../../../services/api';
 import { getEnabledSteps } from '../utils/getEnabledSteps';
 import {
   CHANNELS,
@@ -359,74 +358,121 @@ describe('isSaveDisabled', () => {
 });
 
 describe('handleSave — CCS flow', () => {
+  const ccsConfig = { ...baseConfig, context: { name: 'Order Placed Notification' }, features: {} };
+
   beforeEach(() => {
-    createCentralCommsMetaId.mockResolvedValue({ response: { data: { id: 'meta-123' } } });
-    getCentralCommsMetaIds.mockResolvedValue({ response: { data: {} } });
+    createCommDefinition.mockResolvedValue({
+      response: { data: { id: 'cd_123', referenceId: 'ORDER_PLACED_123', status: 'DRAFT', version: { version: 1 } } },
+    });
   });
 
   afterEach(() => {
     jest.clearAllMocks();
   });
 
-  it('calls createCentralCommsMetaId for each content item when useCCS is not false', async () => {
+  it('calls createCommDefinition with a SINGLE-strategy payload when useCCS is not false', async () => {
     const onSave = jest.fn();
     renderWithFlow({
       features: {},
+      config: ccsConfig,
       initialData: {
-        contentItems: [{ channel: 'sms', templateData: { smsBody: 'Hello' } }],
+        contentItems: [{ channel: 'sms', templateData: { message: 'Hello' } }],
       },
       onSave,
     });
 
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
-    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalledTimes(1));
-    expect(createCentralCommsMetaId).toHaveBeenCalledWith(
+    await waitFor(() => expect(createCommDefinition).toHaveBeenCalledTimes(1));
+    expect(createCommDefinition).toHaveBeenCalledWith(
       expect.objectContaining({
-        centralCommsPayload: expect.objectContaining({ channel: 'SMS', module: 'CAMPAIGNS' }),
+        name: 'Order Placed Notification',
+        strategyType: 'SINGLE',
+        singleChannelStrategy: expect.objectContaining({
+          variant: expect.objectContaining({
+            channel: 'SMS',
+            smsMessageContent: { message: 'Hello' },
+          }),
+        }),
       }),
     );
     expect(onSave).toHaveBeenCalledTimes(1);
   });
 
-  it('calls getCentralCommsMetaIds when metaIds are returned from createCentralCommsMetaId', async () => {
+  it('normalizes the internal MOBILEPUSH channel to CCS\'s MPUSH enum and key names', async () => {
+    const onSave = jest.fn();
     renderWithFlow({
       features: {},
-      initialData: { contentItems: [{ channel: 'EMAIL', templateData: {} }] },
+      config: ccsConfig,
+      initialData: {
+        contentItems: [{ channel: 'MOBILEPUSH', templateData: { messageSubject: 'Hi' } }],
+      },
+      onSave,
     });
 
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
-    await waitFor(() => expect(getCentralCommsMetaIds).toHaveBeenCalledWith('meta-123'));
+    await waitFor(() => expect(createCommDefinition).toHaveBeenCalledTimes(1));
+    expect(createCommDefinition).toHaveBeenCalledWith(
+      expect.objectContaining({
+        singleChannelStrategy: expect.objectContaining({
+          variant: expect.objectContaining({
+            channel: 'MPUSH',
+            mpushMessageContent: { messageSubject: 'Hi' },
+          }),
+        }),
+      }),
+    );
   });
 
-  it('skips getCentralCommsMetaIds when response contains no id', async () => {
-    createCentralCommsMetaId.mockResolvedValue({ response: { data: {} } });
+  it('merges ccsCommDefinition into the data passed to onSave when create succeeds', 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(createCentralCommsMetaId).toHaveBeenCalled());
-    expect(getCentralCommsMetaIds).not.toHaveBeenCalled();
+    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
+    expect(onSave).toHaveBeenCalledWith(
+      expect.objectContaining({
+        ccsCommDefinition: { id: 'cd_123', referenceId: 'ORDER_PLACED_123', version: 1, status: 'DRAFT' },
+      }),
+    );
   });
 
-  it('uses ouId and module from config.context when provided', async () => {
+  it('generates a referenceId from name when config.context.referenceId is absent', async () => {
+    // moduleMocks.js spies on Date.now globally, but this config's resetMocks:true
+    // clears that return value before every test — set it explicitly here.
+    jest.spyOn(Date, 'now').mockReturnValue(1612267539410);
     renderWithFlow({
       features: {},
-      config: { ...baseConfig, context: { ouId: 42, module: 'LOYALTY' }, features: {} },
+      config: ccsConfig,
       initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
     });
 
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
-    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalled());
-    expect(createCentralCommsMetaId).toHaveBeenCalledWith(
-      expect.objectContaining({
-        centralCommsPayload: expect.objectContaining({ ouId: 42, module: 'LOYALTY' }),
-      }),
+    await waitFor(() => expect(createCommDefinition).toHaveBeenCalled());
+    const payload = createCommDefinition.mock.calls[0][0];
+    expect(payload.referenceId).toBe('ORDER_PLACED_NOTIFICATION_1612267539410');
+  });
+
+  it('uses config.context.referenceId and description when provided', async () => {
+    renderWithFlow({
+      features: {},
+      config: { ...ccsConfig, context: { ...ccsConfig.context, referenceId: 'ORDER_PLACED', description: 'desc' } },
+      initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(createCommDefinition).toHaveBeenCalled());
+    expect(createCommDefinition).toHaveBeenCalledWith(
+      expect.objectContaining({ referenceId: 'ORDER_PLACED', description: 'desc' }),
     );
   });
 
@@ -434,7 +480,7 @@ describe('handleSave — CCS flow', () => {
     const onSave = jest.fn();
     renderWithFlow({
       features: {},
-      config: { ...baseConfig, useCCS: false, features: {} },
+      config: { ...ccsConfig, useCCS: false },
       initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
       onSave,
     });
@@ -442,14 +488,15 @@ describe('handleSave — CCS flow', () => {
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
     await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
-    expect(createCentralCommsMetaId).not.toHaveBeenCalled();
+    expect(createCommDefinition).not.toHaveBeenCalled();
+    expect(onSave).toHaveBeenCalledWith(expect.not.objectContaining({ ccsCommDefinition: expect.anything() }));
   });
 
-  it('still calls onSave when createCentralCommsMetaId rejects', async () => {
-    createCentralCommsMetaId.mockRejectedValue(new Error('Network error'));
+  it('skips createCommDefinition when config.context.name is absent (mandatory)', async () => {
     const onSave = jest.fn();
     renderWithFlow({
       features: {},
+      config: { ...baseConfig, features: {} },
       initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
       onSave,
     });
@@ -457,12 +504,70 @@ describe('handleSave — CCS flow', () => {
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
     await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
+    expect(createCommDefinition).not.toHaveBeenCalled();
+  });
+
+  it('skips createCommDefinition for multi-channel strategies (CHANNEL_PRIORITY/AB_TEST)', async () => {
+    const onSave = jest.fn();
+    renderWithFlow({
+      features: {},
+      config: ccsConfig,
+      initialData: {
+        communicationStrategy: CHANNEL_PRIORITY,
+        channels: ['SMS', 'EMAIL'],
+        contentItems: [{ channel: 'SMS', templateData: {} }, { channel: 'EMAIL', templateData: {} }],
+      },
+      onSave,
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
+    expect(createCommDefinition).not.toHaveBeenCalled();
   });
 
-  it('skips createCentralCommsMetaId when contentItems is empty', async () => {
+  it('still calls onSave (without ccsCommDefinition) when createCommDefinition rejects', async () => {
+    createCommDefinition.mockRejectedValue(new Error('Network error'));
     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(onSave).toHaveBeenCalledTimes(1));
+    expect(onSave).toHaveBeenCalledWith(expect.not.objectContaining({ ccsCommDefinition: expect.anything() }));
+  });
+
+  it('blocks save and shows an error when createCommDefinition resolves with a duplicate REFERENCE_ID_EXISTS conflict', async () => {
+    createCommDefinition.mockResolvedValue({
+      success: false,
+      status: { isError: true, code: 409, message: 'REFERENCE_ID_EXISTS' },
+      message: 'REFERENCE_ID_EXISTS',
+    });
+    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(await screen.findByText(/already in use in your organization/i)).toBeInTheDocument();
+    expect(onSave).not.toHaveBeenCalled();
+  });
+
+  it('skips createCommDefinition when contentItems is empty', async () => {
+    const onSave = jest.fn();
+    renderWithFlow({
+      features: {},
+      config: ccsConfig,
       initialData: { contentItems: [] },
       onSave,
     });
@@ -470,12 +575,13 @@ describe('handleSave — CCS flow', () => {
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
     await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
-    expect(createCentralCommsMetaId).not.toHaveBeenCalled();
+    expect(createCommDefinition).not.toHaveBeenCalled();
   });
 
-  it('includes additionalSettings derived from dynamicControls in the payload', async () => {
+  it('places additionalSettings derived from dynamicControls under settings.additionalSettings (not delivery settings)', async () => {
     renderWithFlow({
       features: {},
+      config: ccsConfig,
       initialData: {
         contentItems: [{ channel: 'SMS', templateData: {} }],
         dynamicControls: {
@@ -489,14 +595,36 @@ describe('handleSave — CCS flow', () => {
 
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
-    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalled());
-    const payload = createCentralCommsMetaId.mock.calls[0][0];
-    expect(payload.centralCommsPayload.smsDeliverySettings.additionalSettings).toEqual({
+    await waitFor(() => expect(createCommDefinition).toHaveBeenCalled());
+    const payload = createCommDefinition.mock.calls[0][0];
+    expect(payload.settings.additionalSettings).toEqual({
       useTinyUrl: true,
       encryptUrl: true,
       linkTrackingEnabled: true,
       userSubscriptionDisabled: true,
     });
+    expect(payload.singleChannelStrategy.variant.smsDeliverySettings.additionalSettings).toBeUndefined();
+  });
+
+  it('includes channelSettings from deliverySetting.channelSetting in the payload', async () => {
+    renderWithFlow({
+      features: {},
+      config: ccsConfig,
+      initialData: {
+        contentItems: [{ channel: 'SMS', templateData: {} }],
+        deliverySetting: { channelSetting: { SMS: { domainId: 1001, gsmSenderId: 'BRAND1' } } },
+      },
+    });
+
+    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
+
+    await waitFor(() => expect(createCommDefinition).toHaveBeenCalled());
+    const payload = createCommDefinition.mock.calls[0][0];
+    expect(payload.singleChannelStrategy.variant.smsDeliverySettings.channelSettings).toEqual({
+      channel: 'SMS',
+      domainId: 1001,
+      gsmSenderId: 'BRAND1',
+    });
   });
 });
 
@@ -552,39 +680,34 @@ describe('optional chaining safety', () => {
     jest.clearAllMocks();
   });
 
-  it('defaults ouId to -1 when config.context is absent', async () => {
-    createCentralCommsMetaId.mockResolvedValue({ response: { data: { id: 'x' } } });
+  it('does not crash and skips CCS when config.context is entirely absent', async () => {
+    const onSave = jest.fn();
     renderWithFlow({
       features: {},
+      config: { ...baseConfig, features: {} },
       initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
+      onSave,
     });
 
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
-    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalled());
-    expect(createCentralCommsMetaId).toHaveBeenCalledWith(
-      expect.objectContaining({
-        centralCommsPayload: expect.objectContaining({ ouId: -1 }),
-      }),
-    );
+    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
+    expect(createCommDefinition).not.toHaveBeenCalled();
   });
 
-  it('defaults module to consumer.toUpperCase() when config.context.module absent', async () => {
-    createCentralCommsMetaId.mockResolvedValue({ response: { data: { id: 'x' } } });
+  it('does not crash when config.context is present but empty', async () => {
+    const onSave = jest.fn();
     renderWithFlow({
       features: {},
-      config: { ...baseConfig, consumer: 'loyalty', features: {} },
+      config: { ...baseConfig, context: {}, features: {} },
       initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
+      onSave,
     });
 
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
-    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalled());
-    expect(createCentralCommsMetaId).toHaveBeenCalledWith(
-      expect.objectContaining({
-        centralCommsPayload: expect.objectContaining({ module: 'LOYALTY' }),
-      }),
-    );
+    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
+    expect(createCommDefinition).not.toHaveBeenCalled();
   });
 
   it('initializes channel from config.channel when initialData.channel is absent', () => {

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

@@ -108,6 +108,22 @@ describe('CommunicationFlowCard', () => {
       fireEvent.click(screen.getByText('Add creatives'));
       expect(screen.getByTestId('comm-flow-mock')).toHaveAttribute('data-mode', 'create');
     });
+
+    it('disables the Add creatives button when disabled prop is true', () => {
+      renderCard({ disabled: true, disabledTooltip: 'Enter an Alert name to add content' });
+      expect(screen.getByText('Add creatives').closest('button')).toBeDisabled();
+    });
+
+    it('does not open SlideBox when Add creatives is clicked while disabled', () => {
+      renderCard({ disabled: true, disabledTooltip: 'Enter an Alert name to add content' });
+      fireEvent.click(screen.getByText('Add creatives'));
+      expect(screen.queryByTestId('slide-box')).not.toBeInTheDocument();
+    });
+
+    it('Add creatives button is enabled by default (disabled prop absent)', () => {
+      renderCard();
+      expect(screen.getByText('Add creatives').closest('button')).not.toBeDisabled();
+    });
   });
 
   describe('configured state (initialData provided)', () => {

package/v2Containers/CommunicationFlow/constants.js

@@ -38,6 +38,53 @@ export const CHANNEL_PRIORITY = 'CHANNEL_PRIORITY';
 export const AB_TEST = 'AB_TEST';
 export const SINGLE_TEMPLATE = 'SINGLE_TEMPLATE';
 
+// CCS CommDefinition strategyType — distinct from SINGLE_TEMPLATE above, which
+// is this UI's own communicationStrategy value. Only SINGLE is supported this
+// phase; CCS create is skipped entirely for CHANNEL_PRIORITY/AB_TEST.
+export const CCS_STRATEGY_TYPE_SINGLE = 'SINGLE';
+
+// Mirrors CCS's SingleChannelStrategy field names exactly (Cap Notify API
+// Design doc sample payloads, verified against real create responses). Kept
+// separate from CHANNEL_CONTENT_KEY_MAP/CHANNEL_DELIVERY_KEY_MAP below, which
+// are the legacy messageMeta payload's keys.
+export const CCS_CHANNEL_CONTENT_KEY_MAP = {
+  SMS: 'smsMessageContent',
+  EMAIL: 'emailMessageContent',
+  WHATSAPP: 'whatsappMessageContent',
+  MPUSH: 'mpushMessageContent',
+  INAPP: 'inAppMessageContent',
+  ANDROID: 'androidMessageContent',
+  IOS: 'iosMessageContent',
+  ZALO: 'zaloMessageContent',
+  VIBER: 'viberMessageContent',
+  LINE: 'lineMessageContent',
+  WEBPUSH: 'webPushMessageContent',
+  RCS: 'rcsMessageContent',
+};
+
+export const CCS_CHANNEL_DELIVERY_KEY_MAP = {
+  SMS: 'smsDeliverySettings',
+  EMAIL: 'emailDeliverySettings',
+  WHATSAPP: 'whatsappDeliverySettings',
+  MPUSH: 'mpushDeliverySettings',
+  INAPP: 'inAppDeliverySettings',
+  ANDROID: 'androidDeliverySettings',
+  IOS: 'iosDeliverySettings',
+  ZALO: 'zaloDeliverySettings',
+  VIBER: 'viberDeliverySettings',
+  LINE: 'lineDeliverySettings',
+  WEBPUSH: 'webPushDeliverySettings',
+  RCS: 'rcsDeliverySettings',
+};
+
+// The UI's own internal channel identifier for mobile push is 'MOBILEPUSH'
+// (see CreativesContainer/constants.js MOBILE_PUSH), but CCS's channel enum
+// only recognises 'MPUSH' (globals.js CCS_CHANNELS) — normalize before
+// building the CCS payload. Every other channel identifier matches CCS as-is.
+export const CCS_CHANNEL_NAME_MAP = {
+  MOBILEPUSH: 'MPUSH',
+};
+
 // Channel config - single source of truth for CreativesContainer and TemplatesV2
 // paneKey: TemplatesV2 defaultPanes object key (for channelsToHide)
 // channelProp: CreativesContainer channel prop (must match pane.key for tab to be active)

package/v2Containers/CommunicationFlow/index.js

@@ -9,7 +9,6 @@
 import React from 'react';
 import PropTypes from 'prop-types';
 import CommunicationFlow from './CommunicationFlow';
-import { hasSupportEngagementModule } from '../../utils/common';
 
 const CommunicationFlowContainer = ({
   config,
@@ -18,22 +17,16 @@ const CommunicationFlowContainer = ({
   onCancel,
   onChange,
   ...otherProps
-}) => {
-  if (!hasSupportEngagementModule()) {
-    return null;
-  }
-
-  return (
-    <CommunicationFlow
-      config={config}
-      initialData={initialData}
-      onSave={onSave}
-      onCancel={onCancel}
-      onChange={onChange}
-      {...otherProps}
-    />
-  );
-};
+}) => (
+  <CommunicationFlow
+    config={config}
+    initialData={initialData}
+    onSave={onSave}
+    onCancel={onCancel}
+    onChange={onChange}
+    {...otherProps}
+  />
+);
 
 CommunicationFlowContainer.propTypes = {
   config: PropTypes.shape({
@@ -87,11 +80,13 @@ CommunicationFlowContainer.propTypes = {
         controls: PropTypes.array,
       }),
     }),
-    context: PropTypes.object, // ouId, campaignId, programId, etc.
-    useCCS: PropTypes.bool, // If false, skips CCS bulk-claim-approve on save. Defaults to true.
+    context: PropTypes.object, // ouId, campaignId, programId; name (required for CCS create),
+    // referenceId (optional, auto-generated from name if absent), description (optional).
+    useCCS: PropTypes.bool, // If false, skips the CCS createCommDefinition call on save. Defaults to true.
   }).isRequired,
   initialData: PropTypes.object, // for edit/preview mode
-  onSave: PropTypes.func.isRequired, // (data) => void - called when user saves
+  onSave: PropTypes.func.isRequired, // (data) => void - called when user saves; data.ccsCommDefinition
+  // ({id, referenceId, version, status}) is present when the CCS create succeeded
   onCancel: PropTypes.func.isRequired, // () => void - called when user cancels
   onChange: PropTypes.func, // (data) => void - optional, called on data changes
 };

package/v2Containers/CommunicationFlow/messages.js

@@ -363,4 +363,8 @@ export default {
     id: `${prefix}.senderNotConfiguredError`,
     defaultMessage: 'Selected domain gateway id is not correct. Please change the domain id or contact the gateway team to register them with Capillary.',
   },
+  duplicateReferenceIdError: {
+    id: `${prefix}.duplicateReferenceIdError`,
+    defaultMessage: 'This reference ID is already in use in your organization. Please use a different reference ID.',
+  },
 };