coveo.analytics 2.19.16 → 2.20.3

package/src/insight/insightClient.ts

@@ -0,0 +1,150 @@
+import CoveoAnalyticsClient, {AnalyticsClient, ClientOptions} from '../client/analytics';
+import {NoopAnalytics} from '../client/noopAnalytics';
+import doNotTrack from '../donottrack';
+import {CustomEventRequest, SearchEventRequest} from '../events';
+import {
+    CustomEventsTypes,
+    FacetBaseMeta,
+    FacetMetadata,
+    FacetSortMeta,
+    FacetStateMetadata,
+    QueryErrorMeta,
+    SearchPageEvents,
+} from '../searchPage/searchPageEvents';
+
+export interface InsightClientProvider {
+    getSearchEventRequestPayload: () => Omit<SearchEventRequest, 'actionCause' | 'searchQueryUid'>;
+    getSearchUID: () => string;
+    getBaseMetadata: () => Record<string, any>;
+    getPipeline: () => string;
+    getOriginContext?: () => string;
+    getOriginLevel1: () => string;
+    getOriginLevel2: () => string;
+    getOriginLevel3: () => string;
+    getLanguage: () => string;
+    getIsAnonymous: () => boolean;
+    getFacetState?: () => FacetStateMetadata[];
+}
+
+export interface InsightClientOptions extends ClientOptions {
+    enableAnalytics: boolean;
+}
+
+export class CoveoInsightClient {
+    public coveoAnalyticsClient: AnalyticsClient;
+
+    constructor(private opts: Partial<InsightClientOptions>, private provider: InsightClientProvider) {
+        const shouldDisableAnalytics = opts.enableAnalytics === false || doNotTrack();
+        this.coveoAnalyticsClient = shouldDisableAnalytics ? new NoopAnalytics() : new CoveoAnalyticsClient(opts);
+    }
+
+    public disable() {
+        if (this.coveoAnalyticsClient instanceof CoveoAnalyticsClient) {
+            this.coveoAnalyticsClient.clear();
+        }
+        this.coveoAnalyticsClient = new NoopAnalytics();
+    }
+
+    public enable() {
+        this.coveoAnalyticsClient = new CoveoAnalyticsClient(this.opts);
+    }
+
+    public logInterfaceLoad() {
+        return this.logSearchEvent(SearchPageEvents.interfaceLoad);
+    }
+
+    public logFetchMoreResults() {
+        return this.logCustomEvent(SearchPageEvents.pagerScrolling, {type: 'getMoreResults'});
+    }
+
+    public logFacetSelect(meta: FacetMetadata) {
+        return this.logSearchEvent(SearchPageEvents.facetSelect, meta);
+    }
+
+    public logFacetDeselect(meta: FacetMetadata) {
+        return this.logSearchEvent(SearchPageEvents.facetDeselect, meta);
+    }
+
+    public logFacetUpdateSort(meta: FacetSortMeta) {
+        return this.logSearchEvent(SearchPageEvents.facetUpdateSort, meta);
+    }
+
+    public logFacetClearAll(meta: FacetBaseMeta) {
+        return this.logSearchEvent(SearchPageEvents.facetClearAll, meta);
+    }
+
+    public logFacetShowMore(meta: FacetBaseMeta) {
+        return this.logCustomEvent(SearchPageEvents.facetShowMore, meta);
+    }
+
+    public logFacetShowLess(meta: FacetBaseMeta) {
+        return this.logCustomEvent(SearchPageEvents.facetShowLess, meta);
+    }
+
+    public logQueryError(meta: QueryErrorMeta) {
+        return this.logCustomEvent(SearchPageEvents.queryError, meta);
+    }
+
+    public async logCustomEvent(event: SearchPageEvents, metadata?: Record<string, any>) {
+        const customData = {...this.provider.getBaseMetadata(), ...metadata};
+
+        const payload: CustomEventRequest = {
+            ...(await this.getBaseCustomEventRequest(customData)),
+            eventType: CustomEventsTypes[event]!,
+            eventValue: event,
+        };
+
+        return this.coveoAnalyticsClient.sendCustomEvent(payload);
+    }
+
+    public async logSearchEvent(event: SearchPageEvents, metadata?: Record<string, any>) {
+        return this.coveoAnalyticsClient.sendSearchEvent(await this.getBaseSearchEventRequest(event, metadata));
+    }
+
+    private async getBaseCustomEventRequest(metadata?: Record<string, any>) {
+        return {
+            ...(await this.getBaseEventRequest(metadata)),
+            lastSearchQueryUid: this.provider.getSearchUID(),
+        };
+    }
+
+    private async getBaseSearchEventRequest(
+        event: SearchPageEvents,
+        metadata?: Record<string, any>
+    ): Promise<SearchEventRequest> {
+        return {
+            ...(await this.getBaseEventRequest(metadata)),
+            ...this.provider.getSearchEventRequestPayload(),
+            searchQueryUid: this.provider.getSearchUID(),
+            queryPipeline: this.provider.getPipeline(),
+            actionCause: event,
+        };
+    }
+
+    private async getBaseEventRequest(metadata?: Record<string, any>) {
+        const customData = {...this.provider.getBaseMetadata(), ...metadata};
+        return {
+            ...this.getOrigins(),
+            customData,
+            language: this.provider.getLanguage(),
+            facetState: this.provider.getFacetState ? this.provider.getFacetState() : [],
+            anonymous: this.provider.getIsAnonymous(),
+            clientId: await this.getClientId(),
+        };
+    }
+
+    private getOrigins() {
+        return {
+            originContext: this.provider.getOriginContext?.(),
+            originLevel1: this.provider.getOriginLevel1(),
+            originLevel2: this.provider.getOriginLevel2(),
+            originLevel3: this.provider.getOriginLevel3(),
+        };
+    }
+
+    private getClientId() {
+        return this.coveoAnalyticsClient instanceof CoveoAnalyticsClient
+            ? this.coveoAnalyticsClient.getCurrentVisitorId()
+            : undefined;
+    }
+}

package/src/searchPage/searchPageClient.spec.ts

@@ -10,7 +10,13 @@ import {
 import CoveoAnalyticsClient from '../client/analytics';
 import {NoopAnalytics} from '../client/noopAnalytics';
 import {mockFetch} from '../../tests/fetchMock';
-
+import doNotTrack from '../donottrack';
+jest.mock('../donottrack', () => {
+    return {
+        default: jest.fn(),
+        doNotTrack: jest.fn(),
+    };
+});
 const {fetchMock, fetchMockBeforeEach} = mockFetch();
 
 describe('SearchPageClient', () => {
@@ -651,6 +657,13 @@ describe('SearchPageClient', () => {
         expect(c.coveoAnalyticsClient instanceof NoopAnalytics).toBe(true);
     });
 
+    it('should disable analytics when doNotTrack is enabled', async () => {
+        (doNotTrack as jest.Mock).mockImplementationOnce(() => true);
+
+        const c = new CoveoSearchPageClient({}, provider);
+        expect(c.coveoAnalyticsClient instanceof NoopAnalytics).toBe(true);
+    });
+
     it('should allow disabling analytics after initialization', () => {
         const c = new CoveoSearchPageClient({enableAnalytics: true}, provider);
         expect(c.coveoAnalyticsClient instanceof CoveoAnalyticsClient).toBe(true);

package/src/searchPage/searchPageClient.ts

@@ -28,6 +28,7 @@ import {
 } from './searchPageEvents';
 import {NoopAnalytics} from '../client/noopAnalytics';
 import {formatOmniboxMetadata} from '../formatting/format-omnibox-metadata';
+import doNotTrack from '../donottrack';
 
 export interface SearchPageClientProvider {
     getBaseMetadata: () => Record<string, any>;
@@ -51,8 +52,8 @@ export class CoveoSearchPageClient {
     public coveoAnalyticsClient: AnalyticsClient;
 
     constructor(private opts: Partial<SearchPageClientOptions>, private provider: SearchPageClientProvider) {
-        this.coveoAnalyticsClient =
-            opts.enableAnalytics === false ? new NoopAnalytics() : new CoveoAnalyticsClient(opts);
+        const shouldDisableAnalytics = opts.enableAnalytics === false || doNotTrack();
+        this.coveoAnalyticsClient = shouldDisableAnalytics ? new NoopAnalytics() : new CoveoAnalyticsClient(opts);
     }
 
     public disable() {