@thoughtspot/visual-embed-sdk 1.41.0-pre-render-1 → 1.41.0

package/src/utils/custom-actions.spec.ts

@@ -0,0 +1,431 @@
+import { getCustomActions } from './custom-actions';
+import { CustomAction, CustomActionsPosition, CustomActionTarget } from '../types';
+import { logger } from './logger';
+
+// Mock logger
+jest.mock('./logger', () => ({
+    logger: {
+        warn: jest.fn(),
+        error: jest.fn(),
+    },
+}));
+
+describe('getCustomActions function', () => {
+    describe('Static getCustomActions method', () => {
+        test('should return empty result for empty array', () => {
+            const result = getCustomActions([]);
+            expect(result.actions).toEqual([]);
+            expect(result.errors).toEqual([]);
+        });
+
+        test('should return empty result for null/undefined input', () => {
+            const result1 = getCustomActions(null as any);
+            expect(result1.actions).toEqual([]);
+            expect(result1.errors).toEqual([]);
+
+            const result2 = getCustomActions(undefined as any);
+            expect(result2.actions).toEqual([]);
+            expect(result2.errors).toEqual([]);
+        });
+
+        test('should validate and return valid actions', () => {
+            const actions: CustomAction[] = [
+                {
+                    name: 'Test Action',
+                    id: 'test-id',
+                    target: CustomActionTarget.LIVEBOARD,
+                    position: CustomActionsPosition.PRIMARY,
+                },
+            ];
+            const result = getCustomActions(actions);
+            
+            expect(result.actions).toEqual(actions);
+            expect(result.errors).toEqual([]);
+        });
+
+        test('should reject invalid actions and collect errors', () => {
+            const actions: CustomAction[] = [
+                {
+                    name: 'Valid Action',
+                    id: 'valid-id',
+                    target: CustomActionTarget.LIVEBOARD,
+                    position: CustomActionsPosition.PRIMARY,
+                },
+                {
+                    name: 'Invalid Action',
+                    id: 'invalid-id',
+                    target: CustomActionTarget.SPOTTER,
+                    position: CustomActionsPosition.PRIMARY, // Invalid for SPOTTER
+                },
+            ];
+            const result = getCustomActions(actions);
+            
+            expect(result.actions).toEqual([actions[0]]);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0]).toContain("Position 'PRIMARY' is not supported for spotter-level custom actions. Supported positions: MENU, CONTEXTMENU");
+        });
+
+        test('should sort actions by name', () => {
+            const actions: CustomAction[] = [
+                {
+                    name: 'Zebra Action',
+                    id: 'zebra-id',
+                    target: CustomActionTarget.LIVEBOARD,
+                    position: CustomActionsPosition.PRIMARY,
+                },
+                {
+                    name: 'Alpha Action',
+                    id: 'alpha-id',
+                    target: CustomActionTarget.LIVEBOARD,
+                    position: CustomActionsPosition.MENU,
+                },
+            ];
+            const result = getCustomActions(actions);
+            
+            expect(result.actions).toHaveLength(2);
+            expect(result.actions[0].name).toBe('Alpha Action');
+            expect(result.actions[1].name).toBe('Zebra Action');
+        });
+    });
+
+    describe('Input Validation', () => {
+        test('should return false for null action', () => {
+            const result = getCustomActions([null as any]);
+            expect(result.actions).toEqual([]);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0]).toContain('Custom Action Validation Error: Invalid action object provided');
+        });
+
+        test('should return false for undefined action', () => {
+            const result = getCustomActions([undefined as any]);
+            expect(result.actions).toEqual([]);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0]).toContain('Custom Action Validation Error: Invalid action object provided');
+        });
+
+        test('should return false for non-object action', () => {
+            const result = getCustomActions(['string' as any]);
+            expect(result.actions).toEqual([]);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0]).toContain('Custom Action Validation Error: Invalid action object provided');
+        });
+
+        test('should return false for action missing id', () => {
+            const action = {
+                name: 'Test Action',
+                target: CustomActionTarget.LIVEBOARD,
+                position: CustomActionsPosition.PRIMARY,
+            };
+            const result = getCustomActions([action as CustomAction]);
+            expect(result.actions).toEqual([]);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0]).toContain("Missing required fields: id");
+        });
+
+        test('should return false for action missing name', () => {
+            const action = {
+                id: 'test-id',
+                target: CustomActionTarget.LIVEBOARD,
+                position: CustomActionsPosition.PRIMARY,
+            };
+            const result = getCustomActions([action as CustomAction]);
+            expect(result.actions).toEqual([]);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0]).toContain("Missing required fields: name");
+        });
+
+        test('should return false for action missing target', () => {
+            const action = {
+                id: 'test-id',
+                name: 'Test Action',
+                position: CustomActionsPosition.PRIMARY,
+            };
+            const result = getCustomActions([action as CustomAction]);
+            expect(result.actions).toEqual([]);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0]).toContain("Missing required fields: target");
+        });
+
+        test('should return false for action missing position', () => {
+            const action = {
+                id: 'test-id',
+                name: 'Test Action',
+                target: CustomActionTarget.LIVEBOARD,
+            };
+            const result = getCustomActions([action as CustomAction]);
+            expect(result.actions).toEqual([]);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0]).toContain("Missing required fields: position");
+        });
+    });
+
+    describe('Target Type Validation', () => {
+        test('should reject unsupported target type', () => {
+            const action = {
+                id: 'test-id',
+                name: 'Test Action',
+                target: 'UNSUPPORTED' as any,
+                position: CustomActionsPosition.PRIMARY,
+            };
+            const result = getCustomActions([action]);
+            expect(result.actions).toEqual([]);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0]).toContain("Target type 'UNSUPPORTED' is not supported");
+        });
+
+        test('should accept LIVEBOARD target type', () => {
+            const action = {
+                id: 'test-id',
+                name: 'Test Action',
+                target: CustomActionTarget.LIVEBOARD,
+                position: CustomActionsPosition.PRIMARY,
+            };
+            const result = getCustomActions([action]);
+            expect(result.actions).toEqual([action]);
+            expect(result.errors).toEqual([]);
+        });
+
+        test('should accept VIZ target type', () => {
+            const action = {
+                id: 'test-id',
+                name: 'Test Action',
+                target: CustomActionTarget.VIZ,
+                position: CustomActionsPosition.MENU,
+            };
+            const result = getCustomActions([action]);
+            expect(result.actions).toEqual([action]);
+            expect(result.errors).toEqual([]);
+        });
+
+        test('should accept ANSWER target type', () => {
+            const action = {
+                id: 'test-id',
+                name: 'Test Action',
+                target: CustomActionTarget.ANSWER,
+                position: CustomActionsPosition.MENU,
+            };
+            const result = getCustomActions([action]);
+            expect(result.actions).toEqual([action]);
+            expect(result.errors).toEqual([]);
+        });
+
+        test('should accept SPOTTER target type', () => {
+            const action = {
+                id: 'test-id',
+                name: 'Test Action',
+                target: CustomActionTarget.SPOTTER,
+                position: CustomActionsPosition.MENU,
+            };
+            const result = getCustomActions([action]);
+            expect(result.actions).toEqual([action]);
+            expect(result.errors).toEqual([]);
+        });
+    });
+
+    describe('Position Validation', () => {
+        test('should reject invalid position for LIVEBOARD', () => {
+            const action = {
+                id: 'test-id',
+                name: 'Test Action',
+                target: CustomActionTarget.LIVEBOARD,
+                position: CustomActionsPosition.CONTEXTMENU, // Invalid for LIVEBOARD
+            };
+            const result = getCustomActions([action]);
+            expect(result.actions).toEqual([]);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors).toContain("Position 'CONTEXTMENU' is not supported for liveboard-level custom actions. Supported positions: PRIMARY, MENU");
+        });
+
+        test('should reject invalid position for SPOTTER', () => {
+            const action = {
+                id: 'test-id',
+                name: 'Test Action',
+                target: CustomActionTarget.SPOTTER,
+                position: CustomActionsPosition.PRIMARY, // Invalid for SPOTTER
+            };
+            const result = getCustomActions([action]);
+            expect(result.actions).toEqual([]);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0]).toContain("Position 'PRIMARY' is not supported for spotter-level custom actions. Supported positions: MENU, CONTEXTMENU");
+        });
+
+        test('should accept valid positions for LIVEBOARD', () => {
+            const primaryAction = {
+                id: 'primary-id',
+                name: 'Primary Action',
+                target: CustomActionTarget.LIVEBOARD,
+                position: CustomActionsPosition.PRIMARY,
+            };
+            const menuAction = {
+                id: 'menu-id',
+                name: 'Menu Action',
+                target: CustomActionTarget.LIVEBOARD,
+                position: CustomActionsPosition.MENU,
+            };
+            const result = getCustomActions([primaryAction, menuAction]);
+            expect(result.actions).toHaveLength(2);
+            expect(result.errors).toEqual([]);
+        });
+    });
+
+    describe('Metadata IDs Validation', () => {
+        test('should reject invalid metadata IDs for LIVEBOARD', () => {
+            const action = {
+                id: 'test-id',
+                name: 'Test Action',
+                target: CustomActionTarget.LIVEBOARD,
+                position: CustomActionsPosition.PRIMARY,
+                metadataIds: {
+                    invalidId: 'some-value',
+                },
+            } as any;
+            const result = getCustomActions([action]);
+            expect(result.actions).toEqual([]);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0]).toContain("Invalid metadata IDs for liveboard-level custom actions: invalidId. Supported metadata IDs: liveboardIds");
+        });
+
+        test('should accept valid metadata IDs for LIVEBOARD', () => {
+            const action = {
+                id: 'test-id',
+                name: 'Test Action',
+                target: CustomActionTarget.LIVEBOARD,
+                position: CustomActionsPosition.PRIMARY,
+                metadataIds: {
+                    liveboardIds: ['lb-1', 'lb-2'],
+                },
+            };
+            const result = getCustomActions([action]);
+            expect(result.actions).toEqual([action]);
+            expect(result.errors).toEqual([]);
+        });
+    });
+
+    describe('Data Model IDs Validation', () => {
+        test('should reject invalid data model IDs for VIZ', () => {
+            const action = {
+                id: 'test-id',
+                name: 'Test Action',
+                target: CustomActionTarget.VIZ,
+                position: CustomActionsPosition.MENU,
+                dataModelIds: {
+                    invalidId: 'some-value',
+                },
+            } as any;
+            const result = getCustomActions([action]);
+            expect(result.actions).toEqual([]);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0]).toContain("Invalid data model IDs for viz-level custom actions: invalidId. Supported data model IDs: modelIds, modelColumnNames");
+        });
+
+        test('should accept valid data model IDs for VIZ', () => {
+            const action = {
+                id: 'test-id',
+                name: 'Test Action',
+                target: CustomActionTarget.VIZ,
+                position: CustomActionsPosition.MENU,
+                dataModelIds: {
+                    modelIds: ['model-1'],
+                    modelColumnNames: ['col-1'],
+                },
+            };
+            const result = getCustomActions([action]);
+            expect(result.actions).toEqual([action]);
+            expect(result.errors).toEqual([]);
+        });
+    });
+
+    describe('Field Validation', () => {
+        test('should reject invalid fields for LIVEBOARD', () => {
+            const action = {
+                id: 'test-id',
+                name: 'Test Action',
+                target: CustomActionTarget.LIVEBOARD,
+                position: CustomActionsPosition.PRIMARY,
+                invalidField: 'some-value',
+            };
+            const result = getCustomActions([action]);
+            expect(result.actions).toEqual([]);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0]).toContain("Invalid fields for liveboard-level custom actions: invalidField. Supported fields: name, id, position, target, metadataIds, orgIds, groupIds");
+        });
+
+        test('should accept valid fields for LIVEBOARD', () => {
+            const action = {
+                id: 'test-id',
+                name: 'Test Action',
+                target: CustomActionTarget.LIVEBOARD,
+                position: CustomActionsPosition.PRIMARY,
+                orgIds: ['org-1'],
+                groupIds: ['group-1'],
+            };
+            const result = getCustomActions([action]);
+            expect(result.actions).toEqual([action]);
+            expect(result.errors).toEqual([]);
+        });
+    });
+
+    describe('Duplicate ID Handling', () => {
+        test('should keep only the first action when duplicate IDs are found and report duplicate errors', () => {
+            const action1 = {
+                id: 'duplicate-id',
+                name: 'First Action',
+                target: CustomActionTarget.LIVEBOARD,
+                position: CustomActionsPosition.PRIMARY,
+            };
+            const action2 = {
+                id: 'duplicate-id',
+                name: 'Second Action',
+                target: CustomActionTarget.LIVEBOARD,
+                position: CustomActionsPosition.MENU,
+            };
+            const result = getCustomActions([action1, action2]);
+            expect(result.actions).toHaveLength(1);
+            expect(result.actions[0]).toEqual(action1);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0]).toContain("Duplicate custom action ID 'duplicate-id' found");
+            expect(result.errors[0]).toContain("Actions with names 'Second Action' will be ignored");
+            expect(result.errors[0]).toContain("Keeping 'First Action'");
+        });
+    });
+
+    describe('Complex Validation Scenarios', () => {
+        test('should handle multiple validation errors for a single action', () => {
+            const action = {
+                id: 'test-id',
+                name: 'Test Action',
+                target: CustomActionTarget.LIVEBOARD,
+                position: CustomActionsPosition.CONTEXTMENU, // Invalid position
+                metadataIds: {
+                    invalidId: 'some-value', // Invalid metadata ID
+                },
+                invalidField: 'some-value', // Invalid field
+            } as any;
+            const result = getCustomActions([action]);
+            expect(result.actions).toEqual([]);
+            expect(result.errors).toHaveLength(3);
+            expect(result.errors).toContain("Position 'CONTEXTMENU' is not supported for liveboard-level custom actions. Supported positions: PRIMARY, MENU");
+            expect(result.errors).toContain("Invalid metadata IDs for liveboard-level custom actions: invalidId. Supported metadata IDs: liveboardIds");
+            expect(result.errors).toContain("Invalid fields for liveboard-level custom actions: invalidField. Supported fields: name, id, position, target, metadataIds, orgIds, groupIds");
+        });
+
+        test('should handle mix of valid and invalid actions', () => {
+            const validAction = {
+                id: 'valid-id',
+                name: 'Valid Action',
+                target: CustomActionTarget.LIVEBOARD,
+                position: CustomActionsPosition.PRIMARY,
+            };
+            const invalidAction = {
+                id: 'invalid-id',
+                name: 'Invalid Action',
+                target: CustomActionTarget.SPOTTER,
+                position: CustomActionsPosition.PRIMARY, // Invalid for SPOTTER
+            };
+            const result = getCustomActions([validAction, invalidAction]);
+            expect(result.actions).toEqual([validAction]);
+            expect(result.errors).toHaveLength(1);
+            expect(result.errors[0]).toContain("Position 'PRIMARY' is not supported for spotter-level custom actions. Supported positions: MENU, CONTEXTMENU");
+        });
+    });
+});

package/src/utils/custom-actions.ts

@@ -0,0 +1,217 @@
+import { CustomAction, CustomActionsPosition, CustomActionTarget } from '../types';
+import { arrayIncludesString } from '../utils';
+import sortBy from 'lodash/sortBy';
+import { CUSTOM_ACTIONS_ERROR_MESSAGE } from '../errors';
+
+export interface CustomActionsValidationResult {
+    actions: CustomAction[];
+    errors: string[];
+}
+
+type CustomActionValidation = {
+    isValid: boolean;
+    errors: string[];
+};
+
+/**
+ * Configuration for custom action validation rules.
+ * Defines allowed positions, metadata IDs, data model IDs, and fields for each target
+ * type.
+ * 
+ */
+const customActionValidationConfig: Record<CustomActionTarget, {
+    positions: string[];
+    allowedMetadataIds: string[];
+    allowedDataModelIds: string[];
+    allowedFields: string[];
+}> = {
+    [CustomActionTarget.LIVEBOARD]: {
+        positions: [CustomActionsPosition.PRIMARY, CustomActionsPosition.MENU],
+        allowedMetadataIds: ['liveboardIds'],
+        allowedDataModelIds: [],
+        allowedFields: ['name', 'id', 'position', 'target', 'metadataIds', 'orgIds', 'groupIds'],
+    },
+    [CustomActionTarget.VIZ]: {
+        positions: [CustomActionsPosition.MENU, CustomActionsPosition.PRIMARY, CustomActionsPosition.CONTEXTMENU],
+        allowedMetadataIds: ['liveboardIds', 'vizIds', 'answerIds'],
+        allowedDataModelIds: ['modelIds', 'modelColumnNames'],
+        allowedFields: ['name', 'id', 'position', 'target', 'metadataIds', 'orgIds', 'groupIds', 'dataModelIds'],
+    },
+    [CustomActionTarget.ANSWER]: {
+        positions: [CustomActionsPosition.MENU, CustomActionsPosition.PRIMARY, CustomActionsPosition.CONTEXTMENU],
+        allowedMetadataIds: ['answerIds'],
+        allowedDataModelIds: ['modelIds', 'modelColumnNames'],
+        allowedFields: ['name', 'id', 'position', 'target', 'metadataIds', 'orgIds', 'groupIds', 'dataModelIds'],
+    },
+    [CustomActionTarget.SPOTTER]: {
+        positions: [CustomActionsPosition.MENU, CustomActionsPosition.CONTEXTMENU],
+        allowedMetadataIds: [],
+        allowedDataModelIds: ['modelIds'],
+        allowedFields: ['name', 'id', 'position', 'target', 'orgIds', 'groupIds', 'dataModelIds'],
+    },
+};
+
+/**
+ * Validates a single custom action based on its target type
+ * @param action - The custom action to validate
+ * @param primaryActionsPerTarget - Map to track primary actions per target
+ * @returns CustomActionValidation with isValid flag and reason string
+ * 
+ * @hidden
+ */
+const validateCustomAction = (action: CustomAction, primaryActionsPerTarget: Map<CustomActionTarget, CustomAction>): CustomActionValidation => {
+    const { id: actionId, target: targetType, position, metadataIds, dataModelIds } = action;
+
+    // Check if target type is supported
+    if (!customActionValidationConfig[targetType]) {
+        const errorMessage = CUSTOM_ACTIONS_ERROR_MESSAGE.UNSUPPORTED_TARGET(actionId, targetType);
+        return { isValid: false, errors: [errorMessage] };
+    }
+
+    const config = customActionValidationConfig[targetType];
+    const errors: string[] = [];
+
+    // Validate position
+    if (!arrayIncludesString(config.positions, position)) {
+        const supportedPositions = config.positions.join(', ');
+        errors.push(CUSTOM_ACTIONS_ERROR_MESSAGE.INVALID_POSITION(position, targetType, supportedPositions));
+    }
+
+    // Validate metadata IDs
+    if (metadataIds) {
+        const invalidMetadataIds = Object.keys(metadataIds).filter(
+            (key) => !arrayIncludesString(config.allowedMetadataIds, key)
+        );
+        if (invalidMetadataIds.length > 0) {
+            const supportedMetadataIds = config.allowedMetadataIds.length > 0 ? config.allowedMetadataIds.join(', ') : 'none';
+            errors.push(CUSTOM_ACTIONS_ERROR_MESSAGE.INVALID_METADATA_IDS(targetType, invalidMetadataIds, supportedMetadataIds));
+        }
+    }
+
+    // Validate data model IDs
+    if (dataModelIds) {
+        const invalidDataModelIds = Object.keys(dataModelIds).filter(
+            (key) => !arrayIncludesString(config.allowedDataModelIds, key)
+        );
+        if (invalidDataModelIds.length > 0) {
+            const supportedDataModelIds = config.allowedDataModelIds.length > 0 ? config.allowedDataModelIds.join(', ') : 'none';
+            errors.push(CUSTOM_ACTIONS_ERROR_MESSAGE.INVALID_DATA_MODEL_IDS(targetType, invalidDataModelIds, supportedDataModelIds));
+        }
+    }
+
+    // Validate allowed fields
+    const actionKeys = Object.keys(action);
+    const invalidFields = actionKeys.filter((key) => !arrayIncludesString(config.allowedFields, key));
+    if (invalidFields.length > 0) {
+        const supportedFields = config.allowedFields.join(', ');
+        errors.push(CUSTOM_ACTIONS_ERROR_MESSAGE.INVALID_FIELDS(targetType, invalidFields, supportedFields));
+    }
+
+    return {
+        isValid: errors.length === 0,
+        errors,
+    };
+};
+
+/**
+ * Validates basic action structure and required fields
+ * @param action - The action to validate
+ * @returns Object containing validation result and missing fields
+ * 
+ * @hidden
+ */
+const validateActionStructure = (action: any): { isValid: boolean; missingFields: string[] } => {
+    if (!action || typeof action !== 'object') {
+        return { isValid: false, missingFields: [] };
+    }
+
+    // Check for all missing required fields
+    const missingFields = ['id', 'name', 'target', 'position'].filter(field => !action[field]);
+    return { isValid: missingFields.length === 0, missingFields };
+};
+
+/**
+ * Checks for duplicate IDs among actions
+ * @param actions - Array of actions to check
+ * @returns Object containing filtered actions and duplicate errors
+ * 
+ * @hidden
+ */
+const filterDuplicateIds = (actions: CustomAction[]): { actions: CustomAction[]; errors: string[] } => {
+    const idMap = actions.reduce((map, action) => {
+        const list = map.get(action.id) || [];
+        list.push(action);
+        map.set(action.id, list);
+        return map;
+    }, new Map<string, CustomAction[]>());
+
+    const { actions: actionsWithUniqueIds, errors } = Array.from(idMap.entries()).reduce(
+        (acc, [id, actionsWithSameId]) => {
+            if (actionsWithSameId.length === 1) {
+                acc.actions.push(actionsWithSameId[0]);
+            } else {
+                // Keep the first action and add error for duplicates
+                acc.actions.push(actionsWithSameId[0]);
+                const duplicateNames = actionsWithSameId.slice(1).map(action => action.name);
+                acc.errors.push(CUSTOM_ACTIONS_ERROR_MESSAGE.DUPLICATE_IDS(id, duplicateNames, actionsWithSameId[0].name));
+            }
+            return acc;
+        },
+        { actions: [] as CustomAction[], errors: [] as string[] }
+    );
+
+    return { actions: actionsWithUniqueIds, errors };
+};
+
+/**
+ * Validates and processes custom actions
+ * @param customActions - Array of custom actions to validate
+ * @returns Object containing valid actions and any validation errors
+ */
+export const getCustomActions = (customActions: CustomAction[]): CustomActionsValidationResult => {
+    const errors: string[] = [];
+    const primaryActionsPerTarget = new Map<CustomActionTarget, CustomAction>();
+
+    if (!customActions || !Array.isArray(customActions)) {
+        return { actions: [], errors: [] };
+    }
+
+    // Step 1: Handle invalid actions first (null, undefined, missing required
+    // fields)
+    const validActions = customActions.filter(action => {
+        const validation = validateActionStructure(action);
+        if (!validation.isValid) {
+            if (!action || typeof action !== 'object') {
+                errors.push(CUSTOM_ACTIONS_ERROR_MESSAGE.INVALID_ACTION_OBJECT);
+            } else {
+                errors.push(CUSTOM_ACTIONS_ERROR_MESSAGE.MISSING_REQUIRED_FIELDS((action as any).id, validation.missingFields));
+            }
+            return false;
+        }
+        return true;
+    });
+
+    // Step 2: Check for duplicate IDs among valid actions
+    const { actions: actionsWithUniqueIds, errors: duplicateErrors } = filterDuplicateIds(validActions);
+    
+    // Add duplicate errors to the errors array
+    duplicateErrors.forEach(error => errors.push(error));
+
+    // Step 3: Validate actions with unique IDs
+    const finalValidActions: CustomAction[] = [];
+    actionsWithUniqueIds.forEach((action) => {
+        const { isValid, errors: validationErrors } = validateCustomAction(action, primaryActionsPerTarget);
+        validationErrors.forEach(error => errors.push(error));
+
+        if (isValid) {
+            finalValidActions.push(action);
+        }
+    });
+
+    const sortedActions = sortBy(finalValidActions, (a) => a.name.toLocaleLowerCase());
+
+    return {
+        actions: sortedActions,
+        errors: errors,
+    };
+};

package/src/utils/processData.spec.ts

@@ -279,4 +279,16 @@ describe('Unit test for process data', () => {
         
         mockHandleExitPresentMode.mockReset();
     });
+
+    test('should handle ClearInfoCache', () => {
+        const mockResetCachedPreauthInfo = jest.spyOn(sessionInfoService, 'resetCachedPreauthInfo').mockImplementation(() => {});
+        const mockResetCachedSessionInfo = jest.spyOn(sessionInfoService, 'resetCachedSessionInfo').mockImplementation(() => {});
+        const processedData = {
+            type: EmbedEvent.CLEAR_INFO_CACHE,
+            data: {},
+        };
+        processDataInstance.processEventData(EmbedEvent.CLEAR_INFO_CACHE, processedData, thoughtSpotHost, null);
+        expect(mockResetCachedPreauthInfo).toHaveBeenCalled();
+        expect(mockResetCachedSessionInfo).toHaveBeenCalled();
+    });
 });