@capillarytech/creatives-library 9.0.64 → 9.0.65

package/package.json

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

package/v2Containers/CommunicationFlow/messages.js

@@ -334,6 +334,16 @@ export default {
     id: `${prefix}.rcsAccountLabel`,
     defaultMessage: 'RCS account',
   },
+  /** RCS: SMS fallback domain (slidebox) — shown when the RCS content has SMS-fallback content configured */
+  fallbackSmsDomainLabel: {
+    id: `${prefix}.fallbackSmsDomainLabel`,
+    defaultMessage: 'Fallback SMS domain',
+  },
+  /** RCS: SMS fallback sender ID (slidebox + summary) */
+  fallbackSmsSenderIdLabel: {
+    id: `${prefix}.fallbackSmsSenderIdLabel`,
+    defaultMessage: 'Fallback SMS sender ID',
+  },
   // Dynamic Controls toggle labels and descriptions
   sendToControlCustomers: {
     id: `${prefix}.sendToControlCustomers`,

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

@@ -20,13 +20,15 @@ import {
   buildChannelSettingFromFieldValues,
   parseChannelSettingForDisplay,
   getWhatsappAccountName,
+  hasRcsSmsFallbackContent,
+  RCS_SMS_FALLBACK_CHANNEL,
 } from './deliverySettingsConfig';
 import { getDomainProperties, fetchWeCrmAccounts } from '../../../../services/api';
 import { loadItem } from '../../../../services/localStorageApi';
 import { CHANNELS_WITHOUT_DELIVERY } from '../../constants';
 import messages from '../../messages';
 import './DeliverySettingsSection.scss';
-import { WHATSAPP } from "../../../CreativesContainer/constants";
+import { WHATSAPP, SMS, RCS } from "../../../CreativesContainer/constants";
 
 const DeliverySettingsSection = ({
   contentItems = [],
@@ -60,6 +62,21 @@ const DeliverySettingsSection = ({
     [contentChannels],
   );
 
+  // RCS SMS-fallback sender ID uses SMS domain data even when SMS isn't a selected channel.
+  const hasRcsSmsFallback = useMemo(() => hasRcsSmsFallbackContent(contentItems), [contentItems]);
+
+  // Fetch SMS domain properties for fallback sender options without adding SMS as a displayed channel.
+  const deliveryFetchChannels = useMemo(() => {
+    if (!hasRcsSmsFallback || deliveryChannels.includes(SMS)) return deliveryChannels;
+    return [...deliveryChannels, SMS];
+  }, [deliveryChannels, hasRcsSmsFallback]);
+
+  // Include RCS SMS-fallback fields via a pseudo-channel without rendering an SMS section.
+  const senderDetailsChannels = useMemo(() => {
+    if (!hasRcsSmsFallback) return deliveryChannels;
+    return [...deliveryChannels, RCS_SMS_FALLBACK_CHANNEL];
+  }, [deliveryChannels, hasRcsSmsFallback]);
+
   // Hide section when all configured channels are MPUSH, INAPP, WEBPUSH
   const shouldShow = useMemo(() => {
     if (contentChannels.length === 0) return false;
@@ -79,11 +96,11 @@ const DeliverySettingsSection = ({
   }, [contentItems]);
 
   // Stable key for deduplication - avoid re-fetch when array reference changes
-  const deliveryChannelKey = deliveryChannels.slice().sort().join(',');
+  const deliveryChannelKey = deliveryFetchChannels.slice().sort().join(',');
   const deliveryEnabled = !!deliverySettingsData;
   // Fetch domainProperties when content is configured (single source, deduplicated)
   useEffect(() => {
-    if (!deliveryEnabled || deliveryChannels.length === 0) {
+    if (!deliveryEnabled || deliveryFetchChannels.length === 0) {
       setDomainPropertiesData(null);
       lastChannelKeyRef.current = '';
       return undefined;
@@ -102,7 +119,7 @@ const DeliverySettingsSection = ({
         // uses) so both screens fetch domains for the same org unit; fall back to the logged-in
         // user's own cached OU only when a consumer hasn't supplied one.
         const resolvedOrgUnitId = orgUnitId ?? (loadItem('ouId') || loadItem('orgID'));
-        const response = await getDomainProperties(deliveryChannels, resolvedOrgUnitId);
+        const response = await getDomainProperties(deliveryFetchChannels, resolvedOrgUnitId);
         if (!cancelled) {
           const raw = response?.entity || response;
           // Normalize channel keys to uppercase (API may return Viber, viber, etc.)
@@ -211,7 +228,12 @@ const DeliverySettingsSection = ({
     let didChange = false;
 
     deliveryChannels.forEach((channel) => {
-      const apiDataForChannel = channelSettingFromAPI[channel];
+      let apiDataForChannel = channelSettingFromAPI[channel];
+      // Show RCS SMS-fallback fields only when fallback content is configured, not merely when SMS is selected.
+      if (channel === RCS && !hasRcsSmsFallback && apiDataForChannel) {
+        const { smsFallbackDomainId, smsFallbackSenderId, ...rcsWithoutFallback } = apiDataForChannel;
+        apiDataForChannel = rcsWithoutFallback;
+      }
       const userSavedDataForChannel = savedChannelSetting[channel];
 
       const apiHasRealSenderId = hasRealData(apiDataForChannel);
@@ -300,6 +322,16 @@ const DeliverySettingsSection = ({
                 </CapRow>
               ));
           })}
+          {hasRcsSmsFallback && parsedSenderDetails?.rcsSmsFallbackSenderId && (
+            <CapRow useLegacy key="RCS-rcsSmsFallbackSenderId" type="flex" align="middle" justify="space-between" className="delivery-settings-section__field-row">
+              <CapHeading type="label4" className="delivery-settings-section__label">
+                {formatMessage(messages.fallbackSmsSenderIdLabel)}
+              </CapHeading>
+              <CapLabel type="label9" className="delivery-settings-section__value" title={parsedSenderDetails.rcsSmsFallbackSenderId}>
+                {parsedSenderDetails.rcsSmsFallbackSenderId}
+              </CapLabel>
+            </CapRow>
+          )}
         </CapRow>
         <CapIcon
           type="chevron-right"
@@ -313,7 +345,7 @@ const DeliverySettingsSection = ({
         <SenderDetails
           show={showSlidebox}
           onClose={() => setShowSlidebox(false)}
-          channels={deliveryChannels}
+          channels={senderDetailsChannels}
           preloadedDomainProperties={entityWithWecrmViber}
           isLoadingDomainProperties={isFetchingDomains}
           savedFieldValues={parseChannelSettingForDisplay(deliverySetting?.channelSetting)}

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

@@ -30,6 +30,7 @@ import {
   getSmsDefaultsForDomainId,
   getRcsAccountName,
   getEmailDomainGatewayMapIdByDomainId,
+  getRcsSmsFallbackDefaultDomain,
 } from './deliverySettingsConfig';
 import messages from '../../messages';
 import './SenderDetails.scss';
@@ -114,6 +115,10 @@ const SenderDetails = ({
         next.emailSenderName = defs.senderName;
         next.emailReplyToId = defs.replyToId;
       }
+      if (fieldKey === 'rcsSmsFallbackDomain' && entity) {
+        const defs = getSmsDefaultsForDomainId(entity, value);
+        next.rcsSmsFallbackSenderId = defs.senderId;
+      }
       return next;
     });
   }, [entity]);
@@ -133,6 +138,11 @@ const SenderDetails = ({
         next.emailSenderId = defs.senderId;
         next.emailSenderName = defs.senderName;
         next.emailReplyToId = defs.replyToId;
+      } else if (fieldKey === 'rcsSmsFallbackDomain') {
+        const defaultDomain = getRcsSmsFallbackDefaultDomain(entity);
+        const defs = getSmsDefaultsForDomainId(entity, defaultDomain);
+        next.rcsSmsFallbackDomain = defaultDomain;
+        next.rcsSmsFallbackSenderId = defs.senderId;
       } else {
         next[fieldKey] = getDefaultValueForField(fieldKey, entity, { fieldValues: prev });
       }
@@ -238,7 +248,7 @@ const SenderDetails = ({
 
     if (type === FIELD_TYPE.SELECT) {
       const isSingleOption = options.length <= 1;
-      const isDomainField = fieldKey === 'smsDomain' || fieldKey === 'emailDomain';
+      const isDomainField = fieldKey === 'smsDomain' || fieldKey === 'emailDomain' || fieldKey === 'rcsSmsFallbackDomain';
       const showEmptyOptionsError = !isDisabled && entity && options?.length === 0;
       const emptyOptionsErrorMsg = isDomainField
         ? formatMessage(messages.domainGatewayError)

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

@@ -598,6 +598,100 @@ describe('DeliverySettingsSection — marketer flows', () => {
     });
   });
 
+  describe('RCS SMS-fallback sender ID (normal-flow parity)', () => {
+    const rcsWithFallbackContentItem = {
+      channel: 'RCS',
+      templateData: {
+        smsFallBackContent: { message: 'Fallback SMS body' },
+      },
+    };
+
+    it('fetches SMS domains too (in addition to RCS) when the RCS content has SMS-fallback content', async () => {
+      getDomainProperties.mockResolvedValue({ entity: { ...apiEntity.RCS, ...apiEntity.SMS } });
+
+      renderSection({ contentItems: [rcsWithFallbackContentItem] });
+
+      await waitFor(() => expect(getDomainProperties).toHaveBeenCalledWith(['RCS', 'SMS'], 'test-ou'));
+    });
+
+    it('does not fetch SMS domains when the RCS content has no SMS-fallback content', async () => {
+      getDomainProperties.mockResolvedValue({ entity: apiEntity.RCS });
+
+      renderSection({ contentItems: [{ channel: 'RCS' }] });
+
+      await waitFor(() => expect(getDomainProperties).toHaveBeenCalledWith(['RCS'], 'test-ou'));
+    });
+
+    it('shows a "Fallback SMS sender ID" summary row sourced from the SMS domain default sender', async () => {
+      getDomainProperties.mockResolvedValue({ entity: { ...apiEntity.RCS, ...apiEntity.SMS } });
+
+      renderSection({ contentItems: [rcsWithFallbackContentItem] });
+
+      await waitFor(() => {
+        expect(screen.getByText('Fallback SMS sender ID')).toBeInTheDocument();
+        expect(screen.getByText('+1002003001')).toBeInTheDocument();
+      });
+    });
+
+    it('does not show the fallback summary row when the RCS content has no SMS-fallback content', async () => {
+      getDomainProperties.mockResolvedValue({ entity: apiEntity.RCS });
+
+      renderSection({ contentItems: [{ channel: 'RCS' }] });
+
+      await waitFor(() => expect(screen.getByText('Sender details')).toBeInTheDocument());
+      expect(screen.queryByText('Fallback SMS sender ID')).not.toBeInTheDocument();
+    });
+
+    it('lets the marketer pick a fallback SMS sender ID in the slidebox and persists it under channelSetting.RCS', async () => {
+      getDomainProperties.mockResolvedValue({ entity: { ...apiEntity.RCS, ...apiEntity.SMS } });
+      const onDeliverySettingChange = jest.fn();
+
+      renderSection({ contentItems: [rcsWithFallbackContentItem], onDeliverySettingChange });
+
+      await waitFor(() => expect(screen.getByText('Fallback SMS sender ID')).toBeInTheDocument());
+      onDeliverySettingChange.mockClear();
+      await openSenderDetailsFromSummary();
+
+      const slidebox = document.querySelector('.sender-details');
+      expect(within(slidebox).getByText('Fallback SMS sender ID')).toBeInTheDocument();
+
+      const combos = within(slidebox).getAllByRole('combobox');
+      // RCS domain, RCS sender ID, Fallback SMS domain, Fallback SMS sender ID
+      await userEvent.click(combos[combos.length - 1]);
+      await waitFor(() => expect(screen.getByRole('listbox')).toBeInTheDocument());
+      await userEvent.click(await findVisibleSelectOption('+1002003002'));
+
+      const saveBtn = within(slidebox).getByRole('button', { name: /save changes/i });
+      await waitFor(() => expect(saveBtn).not.toBeDisabled());
+      await userEvent.click(saveBtn);
+
+      expect(onDeliverySettingChange).toHaveBeenCalled();
+      const payload = onDeliverySettingChange.mock.calls[0][0];
+      expect(payload.channelSetting.RCS).toMatchObject({
+        smsFallbackSenderId: '+1002003002',
+      });
+    });
+
+    it('strips smsFallbackDomainId/smsFallbackSenderId from the auto-saved RCS entry when the RCS content has no SMS-fallback content, even though SMS domain data is present (SMS also selected independently)', async () => {
+      // entity.SMS leaks rcsSmsFallbackDomain/rcsSmsFallbackSenderId into channelSettingFromAPI.RCS
+      // via parseSenderDetailsFromEntity, regardless of hasRcsSmsFallback — the auto-save effect
+      // must strip them back out for RCS when there's no actual fallback content configured.
+      getDomainProperties.mockResolvedValue({ entity: { ...apiEntity.RCS, ...apiEntity.SMS } });
+      const onDeliverySettingChange = jest.fn();
+
+      renderSection({
+        contentItems: [{ channel: 'RCS' }, { channel: 'SMS' }],
+        onDeliverySettingChange,
+      });
+
+      await waitFor(() => expect(onDeliverySettingChange).toHaveBeenCalled());
+      const payload = onDeliverySettingChange.mock.calls[0][0];
+      expect(payload.channelSetting.RCS).not.toHaveProperty('smsFallbackDomainId');
+      expect(payload.channelSetting.RCS).not.toHaveProperty('smsFallbackSenderId');
+      expect(payload.channelSetting.RCS).toMatchObject({ senderMobNum: '+12025550123' });
+    });
+  });
+
   describe('DeduplicationRef — skips re-fetch when data already loaded for the same channels', () => {
     it('does not issue a second network call when the same channels are re-rendered with the same deliverySettingsData', async () => {
       // Covers line 85-86: lastChannelKeyRef === deliveryChannelKey && domainPropertiesData already set

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

@@ -448,6 +448,85 @@ describe('SenderDetails', () => {
     });
   });
 
+  it('renders the RCS SMS-fallback domain + sender ID fields when RCS_SMS_FALLBACK_CHANNEL is included', async () => {
+    renderSenderDetails({
+      channels: ['RCS', deliverySettingsConfig.RCS_SMS_FALLBACK_CHANNEL],
+      preloadedDomainProperties: { ...ENTITIES.rcsBrand, ...ENTITIES.smsTwoSenders },
+    });
+    const root = document.querySelector('.sender-details');
+    await waitFor(() => {
+      expect(within(root).getByText('RCS Brand Co')).toBeInTheDocument();
+      expect(within(root).getByText('Fallback SMS domain')).toBeInTheDocument();
+      expect(within(root).getByText('Fallback SMS sender ID')).toBeInTheDocument();
+      expect(within(root).getByText('+1002003001')).toBeInTheDocument();
+    });
+  });
+
+  it('does not render the RCS SMS-fallback fields when the pseudo-channel is not included', async () => {
+    renderSenderDetails({
+      channels: ['RCS'],
+      preloadedDomainProperties: { ...ENTITIES.rcsBrand, ...ENTITIES.smsTwoSenders },
+    });
+    const root = document.querySelector('.sender-details');
+    await waitFor(() => expect(within(root).getByText('RCS Brand Co')).toBeInTheDocument());
+    expect(within(root).queryByText('Fallback SMS domain')).not.toBeInTheDocument();
+  });
+
+  it('changing the fallback SMS domain auto-populates the fallback sender ID', async () => {
+    renderSenderDetails({
+      channels: ['RCS', deliverySettingsConfig.RCS_SMS_FALLBACK_CHANNEL],
+      preloadedDomainProperties: { ...ENTITIES.rcsBrand, ...ENTITIES.smsTwoDomains },
+    });
+    const root = document.querySelector('.sender-details');
+    await waitFor(() => expect(within(root).getByText('Gateway A')).toBeInTheDocument());
+
+    // Combo order for ['RCS', RCS_SMS_FALLBACK_CHANNEL]: rcsAccount (disabled), fallback domain, fallback sender ID.
+    await openSelectAndChoose(root, 1, 'Gateway B');
+    await waitFor(() => expect(within(root).getByText('+222')).toBeInTheDocument());
+  });
+
+  it('resets the fallback SMS domain + sender ID back to the first SMS domain', async () => {
+    renderSenderDetails({
+      channels: ['RCS', deliverySettingsConfig.RCS_SMS_FALLBACK_CHANNEL],
+      preloadedDomainProperties: { ...ENTITIES.rcsBrand, ...ENTITIES.smsTwoDomains },
+    });
+    const root = document.querySelector('.sender-details');
+    await waitFor(() => expect(within(root).getByText('Gateway A')).toBeInTheDocument());
+
+    await openSelectAndChoose(root, 1, 'Gateway B');
+    await waitFor(() => expect(within(root).getByText('+222')).toBeInTheDocument());
+
+    const resetLinks = within(root).getAllByText('Reset');
+    fireEvent.click(resetLinks[resetLinks.length - 2]);
+
+    await waitFor(() => {
+      expect(within(root).getByText('Gateway A')).toBeInTheDocument();
+      expect(within(root).getByText('+111')).toBeInTheDocument();
+    });
+  });
+
+  it('persists the fallback SMS sender ID under rcsSmsFallbackSenderId on save', async () => {
+    const { onSave } = renderSenderDetails({
+      channels: ['RCS', deliverySettingsConfig.RCS_SMS_FALLBACK_CHANNEL],
+      preloadedDomainProperties: { ...ENTITIES.rcsBrand, ...ENTITIES.smsTwoSenders },
+    });
+    const root = document.querySelector('.sender-details');
+    await waitFor(() => expect(within(root).getByText('+1002003001')).toBeInTheDocument());
+
+    const combos = within(root).getAllByRole('combobox');
+    fireEvent.mouseDown(combos[combos.length - 1]);
+    await waitFor(() => expect(screen.getByRole('listbox')).toBeInTheDocument(), WAIT_OPTIONS);
+    fireEvent.click(await findVisibleSelectOption('+1002003002', WAIT_OPTIONS));
+
+    const saveBtn = within(root).getByRole('button', { name: /save changes/i });
+    await waitFor(() => expect(saveBtn).not.toBeDisabled());
+    fireEvent.click(saveBtn);
+
+    expect(onSave).toHaveBeenCalledWith(
+      expect.objectContaining({ rcsSmsFallbackSenderId: '+1002003002' }),
+    );
+  });
+
   it('exposes parseSenderDetailsFromEntity aligned with parseEntityForDisplay', () => {
     expect(parseSenderDetailsFromEntity(ENTITIES.smsOk)).toEqual(
       parseEntityForDisplay(ENTITIES.smsOk, {}),

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

@@ -25,6 +25,10 @@ import {
   buildChannelSettingFromFieldValues,
   hasDomainGateway,
   parseChannelSettingForDisplay,
+  RCS_SMS_FALLBACK_CHANNEL,
+  hasRcsSmsFallbackContent,
+  getRcsSmsFallbackDefaultDomain,
+  getRcsSmsFallbackBodyText,
 } from '../deliverySettingsConfig';
 
 /** Typical campaigns `domainProperties` entity: channel keys → list of gateway rows */
@@ -1001,6 +1005,110 @@ describe('deliverySettingsConfig — user-facing flows', () => {
     });
   });
 
+  describe('RCS SMS-fallback sender ID (normal-flow parity)', () => {
+    it('detects meaningful SMS-fallback content on the RCS contentItem (message field)', () => {
+      expect(hasRcsSmsFallbackContent([
+        { channel: 'RCS', templateData: { smsFallBackContent: { message: 'Hi {{1}}' } } },
+      ])).toBe(true);
+    });
+
+    it('recognizes the alternate smsContent/smsTemplateContent/content keys as meaningful fallback content', () => {
+      expect(hasRcsSmsFallbackContent([
+        { channel: 'RCS', templateData: { smsFallBackContent: { smsContent: 'Hi' } } },
+      ])).toBe(true);
+      expect(hasRcsSmsFallbackContent([
+        { channel: 'RCS', templateData: { smsFallBackContent: { smsTemplateContent: 'Hi' } } },
+      ])).toBe(true);
+      expect(hasRcsSmsFallbackContent([
+        { channel: 'RCS', templateData: { smsFallBackContent: { content: 'Hi' } } },
+      ])).toBe(true);
+    });
+
+    it('is false when there is no RCS content item, no smsFallBackContent, or it is only whitespace', () => {
+      expect(hasRcsSmsFallbackContent([])).toBe(false);
+      expect(hasRcsSmsFallbackContent([{ channel: 'SMS', templateData: {} }])).toBe(false);
+      expect(hasRcsSmsFallbackContent([{ channel: 'RCS', templateData: {} }])).toBe(false);
+      expect(hasRcsSmsFallbackContent([
+        { channel: 'RCS', templateData: { smsFallBackContent: { message: '   ' } } },
+      ])).toBe(false);
+      expect(hasRcsSmsFallbackContent([
+        { channel: 'RCS', templateData: { smsFallBackContent: null } },
+      ])).toBe(false);
+    });
+
+    it('getRcsSmsFallbackBodyText falls all the way through to "" when smsFallBackContent is an object with none of the recognized keys', () => {
+      expect(getRcsSmsFallbackBodyText({})).toBe('');
+      expect(getRcsSmsFallbackBodyText({ unrelatedField: 'x' })).toBe('');
+    });
+
+    it('defaults contentItems to [] (no args) and tolerates a null/non-array contentItems', () => {
+      expect(hasRcsSmsFallbackContent()).toBe(false);
+      expect(hasRcsSmsFallbackContent(null)).toBe(false);
+    });
+
+    it('is false when the RCS-shaped fallback content sits on an item with no channel key (falsy channel branch)', () => {
+      expect(hasRcsSmsFallbackContent([
+        { templateData: { smsFallBackContent: { message: 'Hi' } } },
+      ])).toBe(false);
+    });
+
+    it('exposes fallback domain + sender ID fields only when RCS_SMS_FALLBACK_CHANNEL is requested', () => {
+      const withoutFallback = getFieldsForChannels(['RCS']).map((f) => f.fieldKey);
+      expect(withoutFallback).not.toContain('rcsSmsFallbackDomain');
+      expect(withoutFallback).not.toContain('rcsSmsFallbackSenderId');
+
+      const withFallback = getFieldsForChannels(['RCS', RCS_SMS_FALLBACK_CHANNEL]).map((f) => f.fieldKey);
+      expect(withFallback).toEqual(expect.arrayContaining(['rcsSmsFallbackDomain', 'rcsSmsFallbackSenderId']));
+    });
+
+    it('sources fallback sender ID options from SMS domain data, filtered by the selected fallback domain', () => {
+      const senderField = getFieldsForChannels([RCS_SMS_FALLBACK_CHANNEL]).find((f) => f.fieldKey === 'rcsSmsFallbackSenderId');
+      const opts = senderField.getOptions(domainPropertiesFromApi, { fieldValues: { rcsSmsFallbackDomain: 's2' } });
+      expect(opts.map((o) => o.value)).toEqual(['+2002']);
+    });
+
+    it('sources fallback sender ID options from the first SMS domain when no context is passed at all (default context)', () => {
+      const senderField = getFieldsForChannels([RCS_SMS_FALLBACK_CHANNEL]).find((f) => f.fieldKey === 'rcsSmsFallbackSenderId');
+      const opts = senderField.getOptions(domainPropertiesFromApi);
+      expect(opts.map((o) => o.value)).toContain('+1001');
+    });
+
+    it('defaults the fallback domain to the first SMS domain (for Reset)', () => {
+      expect(getRcsSmsFallbackDefaultDomain(domainPropertiesFromApi)).toBe('s1');
+      expect(getRcsSmsFallbackDefaultDomain(null)).toBe('');
+    });
+
+    it('parseEntityForDisplay includes the fallback domain/sender ID sourced from SMS domain data', () => {
+      const summary = parseEntityForDisplay(domainPropertiesFromApi);
+      expect(summary.rcsSmsFallbackDomain).toBe('s1');
+      expect(summary.rcsSmsFallbackSenderId).toBe('+1001');
+    });
+
+    it('buildChannelSettingFromFieldValues nests fallback domain/sender ID under RCS alongside the RCS sender number', () => {
+      const saved = buildChannelSettingFromFieldValues({
+        rcsSenderNumber: '+r',
+        rcsSmsFallbackDomain: 's2',
+        rcsSmsFallbackSenderId: '+2002',
+      });
+      expect(saved).toEqual({
+        RCS: {
+          senderMobNum: '+r',
+          rcsSender: '+r',
+          smsFallbackDomainId: 's2',
+          smsFallbackSenderId: '+2002',
+        },
+      });
+    });
+
+    it('parseChannelSettingForDisplay hydrates the fallback domain/sender ID back from saved channelSetting', () => {
+      const flat = parseChannelSettingForDisplay({
+        RCS: { rcsSender: '+r', smsFallbackDomainId: 's2', smsFallbackSenderId: '+2002' },
+      });
+      expect(flat.rcsSmsFallbackDomain).toBe('s2');
+      expect(flat.rcsSmsFallbackSenderId).toBe('+2002');
+    });
+  });
+
   describe('getViberAccountOptions — synthetic fallback prepend', () => {
     it('prepends a synthetic entry when the saved viberAccount is absent from API options (stale saved domain)', () => {
       // Triggers the prepend path: context.fieldValues.viberAccount is not present in API options

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

@@ -120,14 +120,16 @@ const getSmsDomainValue = (entity) => {
   return smsData.domainProperties?.id ?? smsData.domainId ?? smsData.id ?? '';
 };
 
-// Sender ID - options only from selected domain (like Email)
-const getSmsSenderIdOptions = (entity, context = {}) => {
-  const selectedDomainId = context?.fieldValues?.smsDomain;
+// Sender ID options restricted to the selected domain; domainFieldKey supports alternate domain field keys.
+const getSmsSenderIdOptionsForDomainField = (entity, context = {}, domainFieldKey = 'smsDomain') => {
+  const selectedDomainId = context?.fieldValues?.[domainFieldKey];
   const domainData = selectedDomainId ? getSmsDomainById(entity, selectedDomainId) : getSmsData(entity);
   if (!domainData) return [];
   return getOptionsFromContactInfo(domainData, 'gsm_sender_id', ['cdma_sender_id']);
 };
 
+const getSmsSenderIdOptions = (entity, context = {}) => getSmsSenderIdOptionsForDomainField(entity, context, 'smsDomain');
+
 const getSmsSenderIdValue = (entity) => {
   const smsData = getSmsData(entity);
   return getValueFromContactInfo(smsData, 'gsm_sender_id', ['cdma_sender_id']);
@@ -359,6 +361,32 @@ export const getRcsAccountName = (entity) => {
   return rcsData.domainProperties?.domainName || rcsData.domainName || rcsData.label || '';
 };
 
+// RCS SMS-fallback fields use SMS domain data and a pseudo-channel to include fallback fields in sender details.
+export const RCS_SMS_FALLBACK_CHANNEL = 'RCS_SMS_FALLBACK';
+
+/** Extract the SMS-fallback body text from an RCS templateData.smsFallBackContent record (CreativesContainer shape). */
+export const getRcsSmsFallbackBodyText = (smsFallBackContent) => {
+  if (!smsFallBackContent || typeof smsFallBackContent !== 'object') return '';
+  return String(
+    smsFallBackContent.message
+      ?? smsFallBackContent.smsContent
+      ?? smsFallBackContent.smsTemplateContent
+      ?? smsFallBackContent.content
+      ?? '',
+  ).trim();
+};
+
+/** True when contentItems has an RCS item whose templateData.smsFallBackContent has real body text. */
+export const hasRcsSmsFallbackContent = (contentItems = []) => {
+  const rcsItem = (contentItems || []).find((item) => (item?.channel || '')?.toUpperCase() === RCS);
+  return getRcsSmsFallbackBodyText(rcsItem?.templateData?.smsFallBackContent) !== '';
+};
+
+/** Default fallback SMS domain (first SMS domain option, same source as the SMS channel field) - for Reset. */
+export const getRcsSmsFallbackDefaultDomain = (entity) => getSmsDomainOptions(entity)?.[0]?.value ?? getSmsDomainValue(entity) ?? '';
+
+const getRcsSmsFallbackSenderIdOptions = (entity, context = {}) => getSmsSenderIdOptionsForDomainField(entity, context, 'rcsSmsFallbackDomain');
+
 
 // --- VIBER account (disabled) + sender ID ---
 // Aligned with adiona-ui/cap-campaigns-v2: domainId + sender (VIBER_SENDER_ID = 'sender')
@@ -524,7 +552,24 @@ export const DELIVERY_SETTINGS_FIELDS = [
     getValue: () => '',
     getOptions: () => [],
   },
-  // RCS sender number: display-only in summary (DeliverySettingsSection); no select/reset in slidebox
+  // RCS sender number is display-only;
+  // SMS-fallback domain/sender ID render only when fallback content is configured.
+  {
+    channel: RCS_SMS_FALLBACK_CHANNEL,
+    fieldKey: 'rcsSmsFallbackDomain',
+    messageKey: 'fallbackSmsDomainLabel',
+    type: FIELD_TYPE.SELECT,
+    getValue: getSmsDomainValue,
+    getOptions: getSmsDomainOptions,
+  },
+  {
+    channel: RCS_SMS_FALLBACK_CHANNEL,
+    fieldKey: 'rcsSmsFallbackSenderId',
+    messageKey: 'fallbackSmsSenderIdLabel',
+    type: FIELD_TYPE.SELECT,
+    getValue: getSmsSenderIdValue,
+    getOptions: (entity, context) => getRcsSmsFallbackSenderIdOptions(entity, context),
+  },
   // VIBER - Viber account (disabled) + Sender ID (select with Reset) - per Figma
   {
     channel: 'VIBER',
@@ -594,6 +639,9 @@ export const parseEntityForDisplay = (entity, context = {}) => {
     whatsappAccountName: getWhatsappAccountName(entity, whatsappSourceAccountId),
     rcsSenderNumber: getRcsSenderNumberValue(entity),
     rcsAccountName: getRcsAccountName(entity),
+    // RCS SMS-fallback: sourced from the SMS domain data (same as the SMS channel's own fields).
+    rcsSmsFallbackDomain: getSmsDomainValue(entity),
+    rcsSmsFallbackSenderId: getSmsSenderIdValue(entity),
     senderNumber: getWhatsappSenderNumberValue(entity, { whatsappSourceAccountId }) || getRcsSenderNumberValue(entity),
   };
 };
@@ -625,10 +673,14 @@ export const buildChannelSettingFromFieldValues = (fieldValues = {}) => {
       senderMobNum: fieldValues.whatsappSenderNumber,
     };
   }
-  if (fieldValues.rcsSenderNumber != null || fieldValues.rcsAccount != null) {
+  if (fieldValues.rcsSenderNumber != null || fieldValues.rcsAccount != null
+    || fieldValues.rcsSmsFallbackDomain != null || fieldValues.rcsSmsFallbackSenderId != null) {
     channelSetting.RCS = {
       senderMobNum: fieldValues.rcsSenderNumber,
       rcsSender: fieldValues.rcsSenderNumber,
+      // SMS-fallback sender ID/domain shown only when RCS SMS-fallback content is configured.
+      ...(fieldValues.rcsSmsFallbackDomain != null && { smsFallbackDomainId: fieldValues.rcsSmsFallbackDomain }),
+      ...(fieldValues.rcsSmsFallbackSenderId != null && { smsFallbackSenderId: fieldValues.rcsSmsFallbackSenderId }),
     };
   }
   // VIBER: aligned with adiona-ui (domainId + sender), campaigns-v2 (gsmSenderId/senderViber)
@@ -697,6 +749,8 @@ export const parseChannelSettingForDisplay = (channelSetting = {}) => {
   }
   if (channelSetting.RCS) {
     out.rcsSenderNumber = channelSetting.RCS.senderMobNum || channelSetting.RCS.rcsSender;
+    out.rcsSmsFallbackDomain = channelSetting.RCS.smsFallbackDomainId;
+    out.rcsSmsFallbackSenderId = channelSetting.RCS.smsFallbackSenderId;
   }
   // VIBER: read sender (adiona) or viberSenderId/gsmSenderId (campaigns compat)
   if (channelSetting.VIBER) {