coveo.analytics 2.28.14 → 2.28.16

package/dist/definitions/client/analyticsBeaconClient.d.ts

@@ -3,9 +3,10 @@ import { EventType, IRequestPayload } from '../events';
 export declare class AnalyticsBeaconClient implements AnalyticsRequestClient {
     private opts;
     constructor(opts: IAnalyticsClientOptions);
-    sendEvent(eventType: EventType, payload: IRequestPayload): Promise<void>;
+    sendEvent(eventType: EventType, originalPayload: IRequestPayload): Promise<void>;
     isAvailable(): boolean;
     deleteHttpCookieVisitorId(): Promise<void>;
+    private preProcessRequestAsPotentialJSONString;
     private encodeForEventType;
     private getQueryParamsForEventType;
     private isEventTypeLegacy;

package/dist/definitions/version.d.ts

@@ -1 +1 @@
-export declare const libVersion = "2.28.14";
+export declare const libVersion = "2.28.16";

package/dist/{library.js → library.cjs}

@@ -731,7 +731,7 @@ function sha1(bytes) {
 const v5 = v35('v5', 0x50, sha1);
 var uuidv5 = v5;
 
-var libVersion = "2.28.14" ;
+var libVersion = "2.28.16" ;
 
 var getFormattedLocation = function (location) {
     return "".concat(location.protocol, "//").concat(location.hostname).concat(location.pathname.indexOf('/') === 0 ? location.pathname : "/".concat(location.pathname)).concat(location.search);
@@ -1205,37 +1205,26 @@ var AnalyticsBeaconClient = (function () {
     function AnalyticsBeaconClient(opts) {
         this.opts = opts;
     }
-    AnalyticsBeaconClient.prototype.sendEvent = function (eventType, payload) {
+    AnalyticsBeaconClient.prototype.sendEvent = function (eventType, originalPayload) {
         return __awaiter(this, void 0, void 0, function () {
-            var _a, baseUrl, preprocessRequest, parsedRequestData, paramsFragments, defaultOptions, _b, url, body, _c, _d;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
+            var _a, baseUrl, preprocessRequest, paramsFragments, _b, url, payload, parsedRequestData, body;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
                         if (!this.isAvailable()) {
                             throw new Error("navigator.sendBeacon is not supported in this browser. Consider adding a polyfill like \"sendbeacon-polyfill\".");
                         }
                         _a = this.opts, baseUrl = _a.baseUrl, preprocessRequest = _a.preprocessRequest;
-                        parsedRequestData = this.encodeForEventType(eventType, payload);
                         return [4, this.getQueryParamsForEventType(eventType)];
                     case 1:
-                        paramsFragments = _e.sent();
-                        defaultOptions = {
-                            url: "".concat(baseUrl, "/analytics/").concat(eventType, "?").concat(paramsFragments),
-                            body: new Blob([parsedRequestData], {
-                                type: 'application/x-www-form-urlencoded',
-                            }),
-                        };
-                        _c = [__assign({}, defaultOptions)];
-                        if (!preprocessRequest) return [3, 3];
-                        return [4, preprocessRequest(defaultOptions, 'analyticsBeacon')];
+                        paramsFragments = _c.sent();
+                        return [4, this.preProcessRequestAsPotentialJSONString("".concat(baseUrl, "/analytics/").concat(eventType, "?").concat(paramsFragments), originalPayload, preprocessRequest)];
                     case 2:
-                        _d = _e.sent();
-                        return [3, 4];
-                    case 3:
-                        _d = {};
-                        _e.label = 4;
-                    case 4:
-                        _b = __assign.apply(void 0, _c.concat([(_d)])), url = _b.url, body = _b.body;
+                        _b = _c.sent(), url = _b.url, payload = _b.payload;
+                        parsedRequestData = this.encodeForEventType(eventType, payload);
+                        body = new Blob([parsedRequestData], {
+                            type: 'application/x-www-form-urlencoded',
+                        });
                         navigator.sendBeacon(url, body);
                         return [2];
                 }
@@ -1248,6 +1237,35 @@ var AnalyticsBeaconClient = (function () {
     AnalyticsBeaconClient.prototype.deleteHttpCookieVisitorId = function () {
         return Promise.resolve();
     };
+    AnalyticsBeaconClient.prototype.preProcessRequestAsPotentialJSONString = function (originalURL, originalPayload, preprocessRequest) {
+        return __awaiter(this, void 0, void 0, function () {
+            var returnedUrl, returnedPayload, processedRequest, processedURL, processedBody;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        returnedUrl = originalURL;
+                        returnedPayload = originalPayload;
+                        if (!preprocessRequest) return [3, 2];
+                        return [4, preprocessRequest({ url: originalURL, body: JSON.stringify(originalPayload) }, 'analyticsBeacon')];
+                    case 1:
+                        processedRequest = _a.sent();
+                        processedURL = processedRequest.url, processedBody = processedRequest.body;
+                        returnedUrl = processedURL || originalURL;
+                        try {
+                            returnedPayload = JSON.parse(processedBody);
+                        }
+                        catch (e) {
+                            console.error('Unable to process the request body as a JSON string', e);
+                        }
+                        _a.label = 2;
+                    case 2: return [2, {
+                            payload: returnedPayload,
+                            url: returnedUrl,
+                        }];
+                }
+            });
+        });
+    };
     AnalyticsBeaconClient.prototype.encodeForEventType = function (eventType, payload) {
         return this.isEventTypeLegacy(eventType)
             ? this.encodeForLegacyType(eventType, payload)

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.14" ;
+const libVersion = "2.28.16" ;
 
 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/modules/package.json

@@ -0,0 +1,11 @@
+{
+    "name": "modules",
+    "private": true,
+    "main": "../dist/library.cjs",
+    "module": "../dist/library.mjs",
+    "browser": "../dist/browser.mjs",
+    "types": "../dist/definitions/coveoua/library.d.ts",
+    "files": [
+        "../dist"
+    ]
+}

package/package.json

@@ -1,9 +1,9 @@
 {
     "name": "coveo.analytics",
-    "version": "2.28.14",
+    "version": "2.28.16",
     "description": "📈 Coveo analytics client (node and browser compatible) ",
-    "main": "dist/library.js",
-    "module": "dist/library.es.js",
+    "main": "dist/library.cjs",
+    "module": "dist/browser.mjs",
     "browser": "dist/coveoua.browser.js",
     "types": "dist/definitions/coveoua/library.d.ts",
     "scripts": {
@@ -65,9 +65,10 @@
         "plist": "3.0.5"
     },
     "files": [
+        "modules/",
         "dist/**/*.d.ts",
-        "dist/**/*.js",
-        "dist/**/*.js.map",
+        "dist/**/*.{js, mjs, cjs}",
+        "dist/**/*.{js, mjs, 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)