@capillarytech/creatives-library 8.0.215 → 8.0.217

package/utils/tests/vendorDataTransformers.test.js

@@ -3,6 +3,7 @@ import {
   transformAssetData,
   transformToVendorFormat,
   getFileHandle,
+  resolveCarouselVideoUpdateFields,
 } from '../vendorDataTransformers';
 
 describe('vendorDataTransformers', () => {
@@ -509,4 +510,434 @@ describe('vendorDataTransformers', () => {
       expect(fileHandle).toBe('haptic_handle_123');
     });
   });
+
+  describe('resolveCarouselVideoUpdateFields', () => {
+    describe('HAPTIC vendor', () => {
+      it('should resolve HAPTIC vendor fields correctly with metaInfo', () => {
+        const data = {
+          metaInfo: {
+            secure_file_path: 'https://haptic.com/video.mp4',
+            hapticFileHandle: 'haptic_handle_123',
+            name: 'sample_video.mp4',
+          },
+          previewUrl: 'https://haptic.com/preview.jpg',
+        };
+        const fallbackVideoSrc = 'https://fallback.com/video.mp4';
+        const fallbackPreviewUrl = 'https://fallback.com/preview.jpg';
+        const fallbackFileHandle = 'fallback_handle';
+
+        const result = resolveCarouselVideoUpdateFields({
+          host: VENDOR_TYPES.HAPTIC,
+          data,
+          videoSrc: fallbackVideoSrc,
+          previewUrl: fallbackPreviewUrl,
+          fileHandle: fallbackFileHandle,
+        });
+
+        expect(result.resolvedVideoSrc).toBe('https://haptic.com/video.mp4');
+        expect(result.resolvedPreviewUrl).toBe('https://haptic.com/preview.jpg');
+        expect(result.resolvedHapticHandle).toBe('haptic_handle_123');
+        expect(result.resolvedKarixHandle).toBe('');
+        expect(result.standardAsset).toEqual({
+          videoSrc: 'https://haptic.com/video.mp4',
+          previewUrl: 'https://haptic.com/preview.jpg',
+          videoName: 'sample_video.mp4',
+          videoDuration: '',
+          fileHandle: 'haptic_handle_123',
+          videoHeight: '',
+          videoWidth: '',
+        });
+        expect(result.updateFields).toEqual([
+          { fieldName: "videoSrc", value: 'https://haptic.com/video.mp4' },
+          { fieldName: "videoPreviewImg", value: 'https://haptic.com/preview.jpg' },
+          { fieldName: "assetList", value: result.standardAsset },
+          { fieldName: "hapticFileHandle", value: 'haptic_handle_123' },
+          { fieldName: "karixFileHandle", value: '' },
+        ]);
+      });
+
+      it('should use fallback values when metaInfo fields are missing for HAPTIC', () => {
+        const data = {
+          metaInfo: {},
+        };
+        const fallbackVideoSrc = 'https://fallback.com/video.mp4';
+        const fallbackPreviewUrl = 'https://fallback.com/preview.jpg';
+        const fallbackFileHandle = 'fallback_handle';
+
+        const result = resolveCarouselVideoUpdateFields({
+          host: VENDOR_TYPES.HAPTIC,
+          data,
+          videoSrc: fallbackVideoSrc,
+          previewUrl: fallbackPreviewUrl,
+          fileHandle: fallbackFileHandle,
+        });
+
+        expect(result.resolvedVideoSrc).toBe(fallbackVideoSrc);
+        expect(result.resolvedPreviewUrl).toBe(fallbackPreviewUrl);
+        expect(result.resolvedHapticHandle).toBe(fallbackFileHandle);
+        expect(result.resolvedKarixHandle).toBe('');
+      });
+
+      it('should prefer metaInfo secure_file_path over fallback videoSrc for HAPTIC', () => {
+        const data = {
+          metaInfo: {
+            secure_file_path: 'https://haptic.com/video.mp4',
+          },
+        };
+        const fallbackVideoSrc = 'https://fallback.com/video.mp4';
+
+        const result = resolveCarouselVideoUpdateFields({
+          host: VENDOR_TYPES.HAPTIC,
+          data,
+          videoSrc: fallbackVideoSrc,
+        });
+
+        expect(result.resolvedVideoSrc).toBe('https://haptic.com/video.mp4');
+      });
+
+      it('should use fallback videoSrc when metaInfo secure_file_path is missing for HAPTIC', () => {
+        const data = {
+          metaInfo: {},
+        };
+        const fallbackVideoSrc = 'https://fallback.com/video.mp4';
+
+        const result = resolveCarouselVideoUpdateFields({
+          host: VENDOR_TYPES.HAPTIC,
+          data,
+          videoSrc: fallbackVideoSrc,
+        });
+
+        expect(result.resolvedVideoSrc).toBe(fallbackVideoSrc);
+      });
+
+      it('should prefer metaInfo hapticFileHandle over fallback fileHandle for HAPTIC', () => {
+        const data = {
+          metaInfo: {
+            hapticFileHandle: 'haptic_handle_123',
+          },
+        };
+        const fallbackFileHandle = 'fallback_handle';
+
+        const result = resolveCarouselVideoUpdateFields({
+          host: VENDOR_TYPES.HAPTIC,
+          data,
+          fileHandle: fallbackFileHandle,
+        });
+
+        expect(result.resolvedHapticHandle).toBe('haptic_handle_123');
+      });
+
+      it('should transform standardAsset correctly for HAPTIC vendor', () => {
+        const data = {
+          metaInfo: {
+            secure_file_path: 'https://haptic.com/video.mp4',
+            name: 'sample_video.mp4',
+            duration: '30',
+            hapticFileHandle: 'haptic_handle_123',
+            height: '720',
+            width: '1280',
+          },
+          previewUrl: 'https://haptic.com/preview.jpg',
+        };
+
+        const result = resolveCarouselVideoUpdateFields({
+          host: VENDOR_TYPES.HAPTIC,
+          data,
+        });
+
+        expect(result.standardAsset).toEqual({
+          videoSrc: 'https://haptic.com/video.mp4',
+          previewUrl: 'https://haptic.com/preview.jpg',
+          videoName: 'sample_video.mp4',
+          videoDuration: '30',
+          fileHandle: 'haptic_handle_123',
+          videoHeight: '720',
+          videoWidth: '1280',
+        });
+      });
+    });
+
+    describe('KARIX vendor', () => {
+      it('should resolve KARIX vendor fields correctly', () => {
+        const data = {
+          videoSrc: 'https://karix.com/video.mp4',
+          previewUrl: 'https://karix.com/preview.jpg',
+          karixFileHandle: 'karix_handle_123',
+        };
+        const fallbackFileHandle = 'fallback_handle';
+
+        const result = resolveCarouselVideoUpdateFields({
+          host: VENDOR_TYPES.KARIX,
+          data,
+          videoSrc: data.videoSrc,
+          previewUrl: data.previewUrl,
+          fileHandle: fallbackFileHandle,
+        });
+
+        expect(result.resolvedVideoSrc).toBe('https://karix.com/video.mp4');
+        expect(result.resolvedPreviewUrl).toBe('https://karix.com/preview.jpg');
+        expect(result.resolvedHapticHandle).toBe('');
+        expect(result.resolvedKarixHandle).toBe(fallbackFileHandle);
+        expect(result.standardAsset).toBe(data);
+      });
+
+      it('should set resolvedKarixHandle from fileHandle parameter for KARIX', () => {
+        const data = {};
+        const fileHandle = 'karix_handle_123';
+
+        const result = resolveCarouselVideoUpdateFields({
+          host: VENDOR_TYPES.KARIX,
+          data,
+          fileHandle,
+        });
+
+        expect(result.resolvedKarixHandle).toBe('karix_handle_123');
+        expect(result.resolvedHapticHandle).toBe('');
+      });
+
+      it('should not transform standardAsset for KARIX vendor', () => {
+        const data = {
+          videoSrc: 'https://karix.com/video.mp4',
+          previewUrl: 'https://karix.com/preview.jpg',
+          customField: 'custom_value',
+        };
+
+        const result = resolveCarouselVideoUpdateFields({
+          host: VENDOR_TYPES.KARIX,
+          data,
+        });
+
+        expect(result.standardAsset).toBe(data);
+        expect(result.standardAsset.customField).toBe('custom_value');
+      });
+    });
+
+    describe('GUPSHUP vendor', () => {
+      it('should resolve GUPSHUP vendor fields correctly', () => {
+        const data = {
+          videoSrc: 'https://gupshup.com/video.mp4',
+          previewUrl: 'https://gupshup.com/preview.jpg',
+        };
+        const fileHandle = 'gupshup_handle_123';
+
+        const result = resolveCarouselVideoUpdateFields({
+          host: VENDOR_TYPES.GUPSHUP,
+          data,
+          videoSrc: data.videoSrc,
+          previewUrl: data.previewUrl,
+          fileHandle,
+        });
+
+        expect(result.resolvedVideoSrc).toBe('https://gupshup.com/video.mp4');
+        expect(result.resolvedPreviewUrl).toBe('https://gupshup.com/preview.jpg');
+        expect(result.resolvedHapticHandle).toBe('');
+        expect(result.resolvedKarixHandle).toBe('gupshup_handle_123');
+        expect(result.standardAsset).toBe(data);
+      });
+
+      it('should set resolvedKarixHandle from fileHandle parameter for GUPSHUP', () => {
+        const data = {};
+        const fileHandle = 'gupshup_handle_123';
+
+        const result = resolveCarouselVideoUpdateFields({
+          host: VENDOR_TYPES.GUPSHUP,
+          data,
+          fileHandle,
+        });
+
+        expect(result.resolvedKarixHandle).toBe('gupshup_handle_123');
+        expect(result.resolvedHapticHandle).toBe('');
+      });
+    });
+
+    describe('Unknown/Other vendors', () => {
+      it('should handle unknown vendor type with standard behavior', () => {
+        const data = {
+          videoSrc: 'https://unknown.com/video.mp4',
+          previewUrl: 'https://unknown.com/preview.jpg',
+        };
+        const fileHandle = 'unknown_handle';
+
+        const result = resolveCarouselVideoUpdateFields({
+          host: 'unknown_vendor',
+          data,
+          videoSrc: data.videoSrc,
+          previewUrl: data.previewUrl,
+          fileHandle,
+        });
+
+        expect(result.resolvedVideoSrc).toBe('https://unknown.com/video.mp4');
+        expect(result.resolvedPreviewUrl).toBe('https://unknown.com/preview.jpg');
+        expect(result.resolvedHapticHandle).toBe('');
+        expect(result.resolvedKarixHandle).toBe('');
+        expect(result.standardAsset).toBe(data);
+      });
+
+      it('should not transform standardAsset for unknown vendor', () => {
+        const data = {
+          videoSrc: 'https://unknown.com/video.mp4',
+          customField: 'custom_value',
+        };
+
+        const result = resolveCarouselVideoUpdateFields({
+          host: 'unknown_vendor',
+          data,
+        });
+
+        expect(result.standardAsset).toBe(data);
+      });
+    });
+
+    describe('Update fields structure', () => {
+      it('should return updateFields array with correct structure', () => {
+        const data = {
+          metaInfo: {
+            secure_file_path: 'https://haptic.com/video.mp4',
+            hapticFileHandle: 'haptic_handle_123',
+          },
+          previewUrl: 'https://haptic.com/preview.jpg',
+        };
+
+        const result = resolveCarouselVideoUpdateFields({
+          host: VENDOR_TYPES.HAPTIC,
+          data,
+        });
+
+        expect(result.updateFields).toHaveLength(5);
+        expect(result.updateFields[0]).toEqual({ fieldName: "videoSrc", value: expect.any(String) });
+        expect(result.updateFields[1]).toEqual({ fieldName: "videoPreviewImg", value: expect.any(String) });
+        expect(result.updateFields[2]).toEqual({ fieldName: "assetList", value: expect.any(Object) });
+        expect(result.updateFields[3]).toEqual({ fieldName: "hapticFileHandle", value: expect.any(String) });
+        expect(result.updateFields[4]).toEqual({ fieldName: "karixFileHandle", value: expect.any(String) });
+      });
+
+      it('should include correct field names in updateFields', () => {
+        const result = resolveCarouselVideoUpdateFields({
+          host: VENDOR_TYPES.KARIX,
+          data: {},
+        });
+
+        const fieldNames = result.updateFields.map((field) => field.fieldName);
+        expect(fieldNames).toEqual([
+          "videoSrc",
+          "videoPreviewImg",
+          "assetList",
+          "hapticFileHandle",
+          "karixFileHandle",
+        ]);
+      });
+    });
+
+    describe('Edge cases', () => {
+      it('should handle null data object', () => {
+        const result = resolveCarouselVideoUpdateFields({
+          host: VENDOR_TYPES.HAPTIC,
+          data: null,
+          videoSrc: 'https://fallback.com/video.mp4',
+        });
+
+        expect(result.resolvedVideoSrc).toBe('https://fallback.com/video.mp4');
+        expect(result.resolvedPreviewUrl).toBe('');
+        expect(result.resolvedHapticHandle).toBe('');
+      });
+
+      it('should handle undefined data object', () => {
+        const result = resolveCarouselVideoUpdateFields({
+          host: VENDOR_TYPES.HAPTIC,
+          data: undefined,
+          videoSrc: 'https://fallback.com/video.mp4',
+        });
+
+        expect(result.resolvedVideoSrc).toBe('https://fallback.com/video.mp4');
+        expect(result.resolvedPreviewUrl).toBe('');
+      });
+
+      it('should handle empty data object', () => {
+        const result = resolveCarouselVideoUpdateFields({
+          host: VENDOR_TYPES.KARIX,
+          data: {},
+          videoSrc: 'https://fallback.com/video.mp4',
+          previewUrl: 'https://fallback.com/preview.jpg',
+          fileHandle: 'fallback_handle',
+        });
+
+        expect(result.resolvedVideoSrc).toBe('https://fallback.com/video.mp4');
+        expect(result.resolvedPreviewUrl).toBe('https://fallback.com/preview.jpg');
+        expect(result.resolvedKarixHandle).toBe('fallback_handle');
+      });
+
+      it('should handle empty strings for all fallback parameters', () => {
+        const result = resolveCarouselVideoUpdateFields({
+          host: VENDOR_TYPES.KARIX,
+          data: {},
+          videoSrc: '',
+          previewUrl: '',
+          fileHandle: '',
+        });
+
+        expect(result.resolvedVideoSrc).toBe('');
+        expect(result.resolvedPreviewUrl).toBe('');
+        expect(result.resolvedKarixHandle).toBe('');
+        expect(result.resolvedHapticHandle).toBe('');
+      });
+
+      it('should handle missing data.metaInfo for HAPTIC vendor', () => {
+        const data = {
+        };
+
+        const result = resolveCarouselVideoUpdateFields({
+          host: VENDOR_TYPES.HAPTIC,
+          data,
+          videoSrc: 'https://fallback.com/video.mp4',
+        });
+
+        expect(result.resolvedVideoSrc).toBe('https://fallback.com/video.mp4');
+        expect(result.resolvedHapticHandle).toBe('');
+      });
+
+      it('should handle empty metaInfo object for HAPTIC vendor', () => {
+        const data = {
+          metaInfo: {},
+        };
+
+        const result = resolveCarouselVideoUpdateFields({
+          host: VENDOR_TYPES.HAPTIC,
+          data,
+          videoSrc: 'https://fallback.com/video.mp4',
+          fileHandle: 'fallback_handle',
+        });
+
+        expect(result.resolvedVideoSrc).toBe('https://fallback.com/video.mp4');
+        expect(result.resolvedHapticHandle).toBe('fallback_handle');
+      });
+    });
+
+    describe('Default parameter values', () => {
+      it('should use default empty string values when parameters are not provided', () => {
+        const result = resolveCarouselVideoUpdateFields({
+          host: VENDOR_TYPES.KARIX,
+          data: {},
+        });
+
+        expect(result.resolvedVideoSrc).toBe('');
+        expect(result.resolvedPreviewUrl).toBe('');
+        expect(result.resolvedKarixHandle).toBe('');
+        expect(result.resolvedHapticHandle).toBe('');
+      });
+
+      it('should work with minimal parameters (only host and data)', () => {
+        const data = {
+          videoSrc: 'https://test.com/video.mp4',
+        };
+
+        const result = resolveCarouselVideoUpdateFields({
+          host: VENDOR_TYPES.KARIX,
+          data,
+        });
+
+        expect(result.updateFields).toBeDefined();
+        expect(result.updateFields).toHaveLength(5);
+      });
+    });
+  });
 });

package/utils/vendorDataTransformers.js

@@ -47,17 +47,15 @@ const transformHapticAssetData = (assetData) => {
 /**
  * Transform standard vendor data structure (Karix, Gupshup, etc.)
  */
-const transformStandardAssetData = (assetData) => {
-  return {
-    videoSrc: get(assetData, 'videoSrc', ''),
-    previewUrl: get(assetData, 'previewUrl', ''),
-    videoName: get(assetData, 'videoName', ''),
-    videoDuration: get(assetData, 'videoDuration', ''),
-    fileHandle: get(assetData, 'karixFileHandle', ''),
-    videoHeight: get(assetData, 'videoHeight', ''),
-    videoWidth: get(assetData, 'videoWidth', ''),
-  };
-};
+const transformStandardAssetData = (assetData) => ({
+  videoSrc: get(assetData, 'videoSrc', ''),
+  previewUrl: get(assetData, 'previewUrl', ''),
+  videoName: get(assetData, 'videoName', ''),
+  videoDuration: get(assetData, 'videoDuration', ''),
+  fileHandle: get(assetData, 'karixFileHandle', ''),
+  videoHeight: get(assetData, 'videoHeight', ''),
+  videoWidth: get(assetData, 'videoWidth', ''),
+});
 
 /**
  * Transform standardized data back to vendor-specific format
@@ -106,3 +104,64 @@ export const getFileHandle = (assetData, vendorType) => {
       return get(assetData, 'karixFileHandle', '') || get(assetData, 'metaInfo.karixFileHandle', '');
   }
 };
+
+/**
+ * Resolve vendor-specific carousel video update fields
+ * Handles different vendor data structures (HAPTIC, KARIX, GUPSHUP) for carousel video updates
+ *
+ * @param {Object} params - Parameters object
+ * @param {string} params.host - Vendor host type (HOST_HAPTIC, HOST_KARIX, HOST_GUPSHUP)
+ * @param {Object} params.data - Asset data object with vendor-specific structure
+ * @param {string} params.videoSrc - Standard video source (fallback)
+ * @param {string} params.previewUrl - Standard preview URL (fallback)
+ * @param {string} params.fileHandle - Standard file handle (fallback)
+ * @returns {Object} Object containing resolved values and carousel update fields array
+ */
+export const resolveCarouselVideoUpdateFields = ({
+  host,
+  data,
+  videoSrc = '',
+  previewUrl = '',
+  fileHandle = '',
+}) => {
+  const HOST_HAPTIC = VENDOR_TYPES.HAPTIC;
+  const HOST_KARIX = VENDOR_TYPES.KARIX;
+  const HOST_GUPSHUP = VENDOR_TYPES.GUPSHUP;
+
+  const resolvedVideoSrc = host === HOST_HAPTIC
+    ? (data?.metaInfo?.secure_file_path || videoSrc)
+    : videoSrc;
+
+  const resolvedPreviewUrl = host === HOST_HAPTIC
+    ? (data?.previewUrl || previewUrl)
+    : previewUrl;
+
+  const resolvedHapticHandle = host === HOST_HAPTIC
+    ? (data?.metaInfo?.hapticFileHandle || fileHandle)
+    : '';
+
+  const resolvedKarixHandle = (host === HOST_KARIX || host === HOST_GUPSHUP)
+    ? fileHandle
+    : '';
+
+  const standardAsset = host === HOST_HAPTIC
+    ? transformAssetData({ ...data, metaInfo: data?.metaInfo }, VENDOR_TYPES.HAPTIC)
+    : data;
+
+  const updateFields = [
+    { fieldName: "videoSrc", value: resolvedVideoSrc },
+    { fieldName: "videoPreviewImg", value: resolvedPreviewUrl },
+    { fieldName: "assetList", value: standardAsset },
+    { fieldName: "hapticFileHandle", value: resolvedHapticHandle },
+    { fieldName: "karixFileHandle", value: resolvedKarixHandle },
+  ];
+
+  return {
+    resolvedVideoSrc,
+    resolvedPreviewUrl,
+    resolvedHapticHandle,
+    resolvedKarixHandle,
+    standardAsset,
+    updateFields,
+  };
+};