feat: support batch forwarding in kits (#1244)

Author: jaissica12

src/batchUploader.ts

@@ -333,6 +333,19 @@ export class BatchUploader {
                     entry[1],
                     mpInstance
                 );
+
+                if (uploadBatchObject) {
+                    try {
+                        mpInstance._Forwarders.sendBatchToForwarders(
+                            uploadBatchObject
+                        );
+                    } catch (e) {
+                        mpInstance.Logger.error(
+                            `Error forwarding batch to kits. ${e}`
+                        );
+                    }
+                }
+
                 const onCreateBatchCallback =
                     mpInstance._Store.SDKConfig.onCreateBatch;
 

src/forwarders.js

@@ -405,6 +405,34 @@ export default function Forwarders(mpInstance, kitBlocker) {
         }
     };
 
+    this.sendBatchToForwarders = function(batch) {
+        if (
+            mpInstance._Store.webviewBridgeEnabled ||
+            !mpInstance._Store.activeForwarders
+        ) {
+            return;
+        }
+
+        for (const forwarder of mpInstance._Store.activeForwarders) {
+            if (forwarder.processBatch) {
+                try {
+                    const batchCopy = mpInstance._Helpers.extend(
+                        true,
+                        {},
+                        batch
+                    );
+                    const result = forwarder.processBatch(batchCopy);
+
+                    if (result) {
+                        mpInstance.Logger.verbose(result);
+                    }
+                } catch (e) {
+                    mpInstance.Logger.verbose(e);
+                }
+            }
+        }
+    };
+
     this.handleForwarderUserAttributes = function(functionNameKey, key, value) {
         if (
             (kitBlocker && kitBlocker.isAttributeKeyBlocked(key)) ||
@@ -747,7 +775,6 @@ export default function Forwarders(mpInstance, kitBlocker) {
             config.filteringConsentRuleValues || {};
         newForwarder.excludeAnonymousUser =
             config.excludeAnonymousUser || false;
-
         return newForwarder;
     };
 

test/jest/batchUploader.spec.ts

@@ -5,6 +5,7 @@ describe('BatchUploader', () => {
     let batchUploader: BatchUploader;
     let mockMPInstance: IMParticleWebSDKInstance;
     let originalFetch: typeof global.fetch;
+    let mockSendBatchToForwarders: jest.Mock;
 
     beforeEach(() => {
         const now = Date.now();
@@ -16,21 +17,36 @@ describe('BatchUploader', () => {
         global.fetch = jest.fn().mockResolvedValue({ ok: true, status: 200 });
 
         // Create a mock mParticle instance with mocked methods for instantiating a BatchUploader
+        mockSendBatchToForwarders = jest.fn();
         mockMPInstance = {
             _Store: {
                 SDKConfig: {
-                    flags: {}
-                }
+                    flags: {},
+                },
+                sideloadedKitsCount: 0,
             },
             _Helpers: {
                 getFeatureFlag: jest.fn().mockReturnValue(false),
                 createServiceUrl: jest.fn().mockReturnValue('https://mock-url.com'),
+                generateUniqueId: jest.fn().mockReturnValue('mock-uuid'),
+            },
+            _Forwarders: {
+                sendBatchToForwarders: mockSendBatchToForwarders,
             },
             Identity: {
                 getCurrentUser: jest.fn().mockReturnValue({
-                    getMPID: () => 'test-mpid'
-                })
-            }
+                    getMPID: () => 'test-mpid',
+                    getConsentState: () => null,
+                    getUserIdentities: () => ({ userIdentities: {} }),
+                    getAllUserAttributes: () => ({}),
+                }),
+            },
+            Logger: {
+                error: jest.fn(),
+                warning: jest.fn(),
+                verbose: jest.fn(),
+                isVerbose: jest.fn().mockReturnValue(false),
+            },
         } as unknown as IMParticleWebSDKInstance;
 
         batchUploader = new BatchUploader(mockMPInstance, 1000);
@@ -41,6 +57,227 @@ describe('BatchUploader', () => {
         global.fetch = originalFetch;
     });
 
+    describe('batch forwarding to kits', () => {
+        it('should call sendBatchToForwarders for each new batch in createNewBatches', () => {
+            const mockEvents = [
+                {
+                    EventName: 'Test Event',
+                    EventDataType: 4,
+                    MPID: 'test-mpid',
+                    SessionId: 'session-1',
+                    EventCategory: 1,
+                    Timestamp: Date.now(),
+                },
+            ];
+
+            const mockUser = {
+                getMPID: () => 'test-mpid',
+                getConsentState: () => null,
+                getUserIdentities: () => ({ userIdentities: {} }),
+                getAllUserAttributes: () => ({}),
+            };
+
+            BatchUploader['createNewBatches'](
+                mockEvents as any,
+                mockUser as any,
+                mockMPInstance
+            );
+
+            expect(mockSendBatchToForwarders).toHaveBeenCalledTimes(1);
+            expect(mockSendBatchToForwarders).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    mpid: 'test-mpid',
+                })
+            );
+        });
+
+        it('should call sendBatchToForwarders before onCreateBatch', () => {
+            const callOrder: string[] = [];
+
+            mockSendBatchToForwarders.mockImplementation(() => {
+                callOrder.push('sendBatchToForwarders');
+            });
+
+            mockMPInstance._Store.SDKConfig.onCreateBatch = (batch) => {
+                callOrder.push('onCreateBatch');
+                return batch;
+            };
+
+            const mockEvents = [
+                {
+                    EventName: 'Test Event',
+                    EventDataType: 4,
+                    MPID: 'test-mpid',
+                    SessionId: 'session-1',
+                    EventCategory: 1,
+                    Timestamp: Date.now(),
+                },
+            ];
+
+            const mockUser = {
+                getMPID: () => 'test-mpid',
+                getConsentState: () => null,
+                getUserIdentities: () => ({ userIdentities: {} }),
+                getAllUserAttributes: () => ({}),
+            };
+
+            BatchUploader['createNewBatches'](
+                mockEvents as any,
+                mockUser as any,
+                mockMPInstance
+            );
+
+            expect(callOrder).toEqual([
+                'sendBatchToForwarders',
+                'onCreateBatch',
+            ]);
+        });
+
+        it('should forward batch before onCreateBatch can modify it', () => {
+            let forwardedEventCount = 0;
+
+            mockSendBatchToForwarders.mockImplementation((batch) => {
+                forwardedEventCount = batch.events.length;
+            });
+
+            mockMPInstance._Store.SDKConfig.onCreateBatch = (batch) => {
+                batch.modified = true;
+                batch.events = [];
+                return batch;
+            };
+
+            const mockEvents = [
+                {
+                    EventName: 'Test Event',
+                    EventDataType: 4,
+                    MPID: 'test-mpid',
+                    SessionId: 'session-1',
+                    EventCategory: 1,
+                    Timestamp: Date.now(),
+                },
+            ];
+
+            const mockUser = {
+                getMPID: () => 'test-mpid',
+                getConsentState: () => null,
+                getUserIdentities: () => ({ userIdentities: {} }),
+                getAllUserAttributes: () => ({}),
+            };
+
+            BatchUploader['createNewBatches'](
+                mockEvents as any,
+                mockUser as any,
+                mockMPInstance
+            );
+
+            expect(forwardedEventCount).toBe(1);
+        });
+
+        it('should forward batch even when onCreateBatch drops it', () => {
+            mockMPInstance._Store.SDKConfig.onCreateBatch = () => {
+                return null;
+            };
+
+            (mockMPInstance.Logger as any).warning = jest.fn();
+
+            const mockEvents = [
+                {
+                    EventName: 'Test Event',
+                    EventDataType: 4,
+                    MPID: 'test-mpid',
+                    SessionId: 'session-1',
+                    EventCategory: 1,
+                    Timestamp: Date.now(),
+                },
+            ];
+
+            const mockUser = {
+                getMPID: () => 'test-mpid',
+                getConsentState: () => null,
+                getUserIdentities: () => ({ userIdentities: {} }),
+                getAllUserAttributes: () => ({}),
+            };
+
+            BatchUploader['createNewBatches'](
+                mockEvents as any,
+                mockUser as any,
+                mockMPInstance
+            );
+
+            expect(mockSendBatchToForwarders).toHaveBeenCalledTimes(1);
+        });
+
+        it('should not throw if sendBatchToForwarders errors', () => {
+            mockSendBatchToForwarders.mockImplementation(() => {
+                throw new Error('Kit failure');
+            });
+
+            const mockEvents = [
+                {
+                    EventName: 'Test Event',
+                    EventDataType: 4,
+                    MPID: 'test-mpid',
+                    SessionId: 'session-1',
+                    EventCategory: 1,
+                    Timestamp: Date.now(),
+                },
+            ];
+
+            const mockUser = {
+                getMPID: () => 'test-mpid',
+                getConsentState: () => null,
+                getUserIdentities: () => ({ userIdentities: {} }),
+                getAllUserAttributes: () => ({}),
+            };
+
+            expect(() => {
+                BatchUploader['createNewBatches'](
+                    mockEvents as any,
+                    mockUser as any,
+                    mockMPInstance
+                );
+            }).not.toThrow();
+
+            expect(mockMPInstance.Logger.error).toHaveBeenCalled();
+        });
+
+        it('should create separate batches per MPID and forward each', () => {
+            const mockEvents = [
+                {
+                    EventName: 'Event User A',
+                    EventDataType: 4,
+                    MPID: 'mpid-a',
+                    SessionId: 'session-1',
+                    EventCategory: 1,
+                    Timestamp: Date.now(),
+                },
+                {
+                    EventName: 'Event User B',
+                    EventDataType: 4,
+                    MPID: 'mpid-b',
+                    SessionId: 'session-1',
+                    EventCategory: 1,
+                    Timestamp: Date.now(),
+                },
+            ];
+
+            const mockUser = {
+                getMPID: () => 'mpid-a',
+                getConsentState: () => null,
+                getUserIdentities: () => ({ userIdentities: {} }),
+                getAllUserAttributes: () => ({}),
+            };
+
+            BatchUploader['createNewBatches'](
+                mockEvents as any,
+                mockUser as any,
+                mockMPInstance
+            );
+
+            expect(mockSendBatchToForwarders).toHaveBeenCalledTimes(2);
+        });
+    });
+
     describe('shouldDebounceAST', () => {
         it('should return false for first call', () => {
             // First call should not be debounced