coveo.analytics 2.28.15 → 2.28.17

package/dist/react-native.es.js

@@ -658,7 +658,7 @@ const addPageViewToHistory = (pageViewValue) => __awaiter(void 0, void 0, void 0
     yield store.addElementAsync(historyElement);
 });
 
-const libVersion = "2.28.15" ;
+const libVersion = "2.28.17" ;
 
 const getFormattedLocation = (location) => `${location.protocol}//${location.hostname}${location.pathname.indexOf('/') === 0 ? location.pathname : `/${location.pathname}`}${location.search}`;
 
@@ -1069,21 +1069,18 @@ class AnalyticsBeaconClient {
     constructor(opts) {
         this.opts = opts;
     }
-    sendEvent(eventType, payload) {
+    sendEvent(eventType, originalPayload) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.isAvailable()) {
                 throw new Error(`navigator.sendBeacon is not supported in this browser. Consider adding a polyfill like "sendbeacon-polyfill".`);
             }
             const { baseUrl, preprocessRequest } = this.opts;
-            const parsedRequestData = this.encodeForEventType(eventType, payload);
             const paramsFragments = yield this.getQueryParamsForEventType(eventType);
-            const defaultOptions = {
-                url: `${baseUrl}/analytics/${eventType}?${paramsFragments}`,
-                body: new Blob([parsedRequestData], {
-                    type: 'application/x-www-form-urlencoded',
-                }),
-            };
-            const { url, body } = Object.assign(Object.assign({}, defaultOptions), (preprocessRequest ? yield preprocessRequest(defaultOptions, 'analyticsBeacon') : {}));
+            const { url, payload } = yield this.preProcessRequestAsPotentialJSONString(`${baseUrl}/analytics/${eventType}?${paramsFragments}`, originalPayload, preprocessRequest);
+            const parsedRequestData = this.encodeForEventType(eventType, payload);
+            const body = new Blob([parsedRequestData], {
+                type: 'application/x-www-form-urlencoded',
+            });
             navigator.sendBeacon(url, body);
             return;
         });
@@ -1094,6 +1091,27 @@ class AnalyticsBeaconClient {
     deleteHttpCookieVisitorId() {
         return Promise.resolve();
     }
+    preProcessRequestAsPotentialJSONString(originalURL, originalPayload, preprocessRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let returnedUrl = originalURL;
+            let returnedPayload = originalPayload;
+            if (preprocessRequest) {
+                const processedRequest = yield preprocessRequest({ url: originalURL, body: JSON.stringify(originalPayload) }, 'analyticsBeacon');
+                const { url: processedURL, body: processedBody } = processedRequest;
+                returnedUrl = processedURL || originalURL;
+                try {
+                    returnedPayload = JSON.parse(processedBody);
+                }
+                catch (e) {
+                    console.error('Unable to process the request body as a JSON string', e);
+                }
+            }
+            return {
+                payload: returnedPayload,
+                url: returnedUrl,
+            };
+        });
+    }
     encodeForEventType(eventType, payload) {
         return this.isEventTypeLegacy(eventType)
             ? this.encodeForLegacyType(eventType, payload)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "coveo.analytics",
-    "version": "2.28.15",
+    "version": "2.28.17",
     "description": "📈 Coveo analytics client (node and browser compatible) ",
     "main": "dist/library.cjs",
     "module": "dist/browser.mjs",
@@ -67,8 +67,12 @@
     "files": [
         "modules/",
         "dist/**/*.d.ts",
-        "dist/**/*.{js, mjs, cjs}",
-        "dist/**/*.{js, mjs, cjs}.map",
+        "dist/**/*.js",
+        "dist/**/*.mjs",
+        "dist/**/*.cjs",
+        "dist/**/*.js.map",
+        "dist/**/*.mjs.map",
+        "dist/**/*.cjs.map",
         "src/**/*.ts",
         "react-native/",
         "LICENSE"

package/src/client/analyticsBeaconClient.spec.ts

@@ -1,6 +1,6 @@
 import {AnalyticsBeaconClient} from './analyticsBeaconClient';
 import {EventType} from '../events';
-import {AnalyticsClientOrigin, IAnalyticsRequestOptions} from './analyticsRequestClient';
+import {AnalyticsClientOrigin, IAnalyticsRequestOptions, PreprocessAnalyticsRequest} from './analyticsRequestClient';
 
 describe('AnalyticsBeaconClient', () => {
     const baseUrl = 'https://bloup.com';
@@ -99,33 +99,94 @@ describe('AnalyticsBeaconClient', () => {
         );
     });
 
-    it('should preprocess the request with the preprocessRequest', async () => {
-        let clientOrigin: AnalyticsClientOrigin;
-        const processedRequest: IAnalyticsRequestOptions = {
-            url: 'https://www.myownanalytics.com/endpoint',
-            body: JSON.stringify({
-                test: 'custom',
-            }),
-        };
-        const client = new AnalyticsBeaconClient({
-            baseUrl,
-            token,
-            visitorIdProvider: {
-                getCurrentVisitorId: () => {
-                    return Promise.resolve(currentVisitorId);
+    describe('allows to preprocessRequest', () => {
+        const setupClient = (preprocessRequest: PreprocessAnalyticsRequest) => {
+            return new AnalyticsBeaconClient({
+                baseUrl,
+                token,
+                visitorIdProvider: {
+                    getCurrentVisitorId: () => {
+                        return Promise.resolve(currentVisitorId);
+                    },
+                    setCurrentVisitorId: () => {},
                 },
-                setCurrentVisitorId: () => {},
-            },
-            preprocessRequest: (_request, type) => {
+                preprocessRequest,
+            });
+        };
+
+        it('to modify the origin and the body of the request', async () => {
+            let clientOrigin: AnalyticsClientOrigin;
+            const processedRequest: IAnalyticsRequestOptions = {
+                url: 'https://www.myownanalytics.com/endpoint',
+                body: JSON.stringify({
+                    test: 'custom',
+                }),
+            };
+            const client = setupClient((_request, type) => {
                 clientOrigin = type;
                 return processedRequest;
-            },
+            });
+
+            await client.sendEvent(EventType.collect, {});
+
+            expect(clientOrigin!).toBe('analyticsBeacon');
+            expect(sendBeaconMock).toHaveBeenCalledWith(processedRequest.url, expect.anything());
+            expect(await getSendBeaconFirstCallBlobArgument()).toContain('test=custom');
         });
 
-        await client.sendEvent(EventType.collect, {});
+        it('to modify the request body as a JSON string for a collect event', async () => {
+            const client = setupClient((request) => {
+                const bodyShouldBeAvailableAsJSONString = JSON.parse(request.body as string);
+                expect(bodyShouldBeAvailableAsJSONString).toEqual({foo: 'bar'});
+                bodyShouldBeAvailableAsJSONString.foo = 'baz';
+                request.body = JSON.stringify(bodyShouldBeAvailableAsJSONString);
+                return request;
+            });
+
+            await client.sendEvent(EventType.collect, {foo: 'bar'});
+            expect(await getSendBeaconFirstCallBlobArgument()).toContain(`foo=baz`);
+        });
+
+        it('to modify the request body as a JSON string for a click event', async () => {
+            const client = setupClient((request) => {
+                const bodyParsedAsJSON = JSON.parse(request.body as string);
+                expect(bodyParsedAsJSON).toEqual({actionCause: 'foo'});
+                bodyParsedAsJSON.actionCause = 'bar';
+                request.body = JSON.stringify(bodyParsedAsJSON);
+                return request;
+            });
+
+            await client.sendEvent(EventType.click, {actionCause: 'foo'});
+            expect(await getSendBeaconFirstCallBlobArgument()).toContain(
+                `clickEvent=${encodeURIComponent(`{"actionCause":"bar"}`)}`
+            );
+        });
 
-        expect(clientOrigin!).toBe('analyticsBeacon');
-        expect(sendBeaconMock).toHaveBeenCalledWith(processedRequest.url, processedRequest.body);
+        it('to augment the request body as a JSON string for a click event', async () => {
+            const client = setupClient((request) => {
+                const bodyParsedAsJSON = JSON.parse(request.body as string);
+                bodyParsedAsJSON.aNewProperty = 'bar';
+                request.body = JSON.stringify(bodyParsedAsJSON);
+                return request;
+            });
+
+            await client.sendEvent(EventType.click, {actionCause: 'foo'});
+            expect(await getSendBeaconFirstCallBlobArgument()).toContain(
+                `clickEvent=${encodeURIComponent(`{"actionCause":"foo","aNewProperty":"bar"}`)}`
+            );
+        });
+
+        it('should keep original request body if preprocessRequest returns an invalid JSON string', async () => {
+            const client = setupClient((request) => {
+                request.body = 'invalid JSON string';
+                return request;
+            });
+
+            await client.sendEvent(EventType.click, {actionCause: 'bar'});
+            expect(await getSendBeaconFirstCallBlobArgument()).toContain(
+                `clickEvent=${encodeURIComponent(`{"actionCause":"bar"}`)}`
+            );
+        });
     });
 
     const getSendBeaconFirstCallBlobArgument = async () => {

package/src/client/analyticsBeaconClient.ts

@@ -1,10 +1,10 @@
-import {AnalyticsRequestClient, IAnalyticsRequestOptions, IAnalyticsClientOptions} from './analyticsRequestClient';
+import {AnalyticsRequestClient, IAnalyticsClientOptions, PreprocessAnalyticsRequest} from './analyticsRequestClient';
 import {EventType, IRequestPayload} from '../events';
 
 export class AnalyticsBeaconClient implements AnalyticsRequestClient {
     constructor(private opts: IAnalyticsClientOptions) {}
 
-    public async sendEvent(eventType: EventType, payload: IRequestPayload): Promise<void> {
+    public async sendEvent(eventType: EventType, originalPayload: IRequestPayload): Promise<void> {
         if (!this.isAvailable()) {
             throw new Error(
                 `navigator.sendBeacon is not supported in this browser. Consider adding a polyfill like "sendbeacon-polyfill".`
@@ -12,18 +12,19 @@ export class AnalyticsBeaconClient implements AnalyticsRequestClient {
         }
 
         const {baseUrl, preprocessRequest} = this.opts;
-        const parsedRequestData = this.encodeForEventType(eventType, payload);
+
         const paramsFragments = await this.getQueryParamsForEventType(eventType);
-        const defaultOptions: IAnalyticsRequestOptions = {
-            url: `${baseUrl}/analytics/${eventType}?${paramsFragments}`,
-            body: new Blob([parsedRequestData], {
-                type: 'application/x-www-form-urlencoded',
-            }),
-        };
-        const {url, body}: IAnalyticsRequestOptions = {
-            ...defaultOptions,
-            ...(preprocessRequest ? await preprocessRequest(defaultOptions, 'analyticsBeacon') : {}),
-        };
+
+        const {url, payload} = await this.preProcessRequestAsPotentialJSONString(
+            `${baseUrl}/analytics/${eventType}?${paramsFragments}`,
+            originalPayload,
+            preprocessRequest
+        );
+
+        const parsedRequestData = this.encodeForEventType(eventType, payload);
+        const body = new Blob([parsedRequestData], {
+            type: 'application/x-www-form-urlencoded',
+        });
 
         navigator.sendBeacon(url, body as any); // https://github.com/microsoft/TypeScript/issues/38715
         return;
@@ -37,6 +38,34 @@ export class AnalyticsBeaconClient implements AnalyticsRequestClient {
         return Promise.resolve();
     }
 
+    private async preProcessRequestAsPotentialJSONString(
+        originalURL: string,
+        originalPayload: IRequestPayload,
+        preprocessRequest?: PreprocessAnalyticsRequest
+    ): Promise<{url: string; payload: IRequestPayload}> {
+        let returnedUrl = originalURL;
+        let returnedPayload = originalPayload;
+
+        if (preprocessRequest) {
+            const processedRequest = await preprocessRequest(
+                {url: originalURL, body: JSON.stringify(originalPayload)},
+                'analyticsBeacon'
+            );
+            const {url: processedURL, body: processedBody} = processedRequest;
+            returnedUrl = processedURL || originalURL;
+            try {
+                returnedPayload = JSON.parse(processedBody as string);
+            } catch (e) {
+                console.error('Unable to process the request body as a JSON string', e);
+            }
+        }
+
+        return {
+            payload: returnedPayload,
+            url: returnedUrl,
+        };
+    }
+
     private encodeForEventType(eventType: EventType, payload: IRequestPayload): string {
         return this.isEventTypeLegacy(eventType)
             ? this.encodeForLegacyType(eventType, payload)