coveo.analytics 2.18.49 → 2.18.53

package/src/caseAssist/caseAssistClient.spec.ts

@@ -0,0 +1,262 @@
+import {CaseAssistClient} from './caseAssistClient';
+import {
+    CaseAssistActions,
+    CaseAssistEvents,
+    CaseCancelledReasons,
+    DocumentSuggestion,
+    FieldSuggestion,
+} from './caseAssistActions';
+
+import {mockFetch} from '../../tests/fetchMock';
+import {TicketProperties} from '../plugins/svc';
+
+const {fetchMock, fetchMockBeforeEach} = mockFetch();
+
+describe('CaseAssistClient', () => {
+    let client: CaseAssistClient;
+
+    beforeEach(() => {
+        fetchMockBeforeEach();
+
+        client = initClient();
+        fetchMock.mock(/.*/, {
+            visitorId: 'visitor-id',
+        });
+    });
+
+    afterEach(() => {
+        fetchMock.reset();
+    });
+
+    const initClient = () => {
+        return new CaseAssistClient({
+            enableAnalytics: true,
+        });
+    };
+
+    const noTicket: Record<string, unknown> = undefined;
+    const noActionData: Record<string, unknown> = undefined;
+    const emptyTicket: TicketProperties = {};
+
+    const fakeTicket: TicketProperties = {
+        id: 'the-ticket-id',
+        subject: 'the ticket subject',
+        description: 'the ticket description',
+        category: 'ticket-category',
+        productId: 'some-product-id',
+        custom: {
+            customA: 'custom-a-value',
+            customB: 'custom-b-value',
+        },
+    };
+
+    const fakeFieldSuggestion: FieldSuggestion = {
+        classification: {
+            value: 'some-field-value',
+            confidence: 0.5,
+        },
+        classificationId: 'field-suggestion-id',
+        fieldName: 'some-field',
+        responseId: 'field-suggestion-response-id',
+    };
+
+    const fakeDocumentSuggestion: DocumentSuggestion = {
+        responseId: 'document-suggestion-response-id',
+        suggestionId: 'document-suggestion-id',
+        suggestion: {
+            documentPosition: 0,
+            documentTitle: 'the document title',
+            documentUri: 'some-document-uri',
+            documentUriHash: 'documenturihash',
+            documentUrl: 'some-document-url',
+        },
+    };
+
+    const expectMatchPayload = (actionName: CaseAssistActions, actionData: Object, ticket: TicketProperties) => {
+        const [, {body}] = fetchMock.lastCall();
+        const content = JSON.parse(body.toString());
+
+        expectMatchActionPayload(content, actionName, actionData);
+        expectMatchTicketPayload(content, ticket);
+    };
+
+    const expectMatchActionPayload = (
+        content: Record<string, unknown>,
+        actionName: CaseAssistActions,
+        actionData: Object
+    ) => {
+        expectMatchProperty(content, 'ec', 'svc');
+        expectMatchProperty(content, 'svc_action', actionName);
+        expectMatchProperty(content, 'svc_action_data', actionData);
+
+        const expectedEvent =
+            actionName === CaseAssistActions.enterInterface ? CaseAssistEvents.flowStart : CaseAssistEvents.click;
+        expectMatchProperty(content, 'ea', expectedEvent);
+    };
+
+    const expectMatchTicketPayload = (content: Record<string, unknown>, ticket?: TicketProperties) => {
+        expectMatchProperty(content, 'svc_ticket_id', ticket?.id);
+        expectMatchProperty(content, 'svc_ticket_subject', ticket?.subject);
+        expectMatchProperty(content, 'svc_ticket_description', ticket?.description);
+        expectMatchProperty(content, 'svc_ticket_category', ticket?.category);
+        expectMatchProperty(content, 'svc_ticket_product_id', ticket?.productId);
+        expectMatchProperty(content, 'svc_ticket_custom', ticket?.custom);
+    };
+
+    const expectMatchProperty = (content: Record<string, unknown>, propName: string, propValue: unknown) => {
+        if (typeof propValue !== 'undefined') {
+            if (typeof propValue === 'object') {
+                expect(content).toHaveProperty(propName);
+                expect(content[propName]).toMatchObject(propValue);
+            } else {
+                expect(content).toHaveProperty(propName, propValue);
+            }
+        } else {
+            expect(content).not.toHaveProperty(propName);
+        }
+    };
+
+    it('should have #enableAnalytics default to #true', async () => {
+        client = new CaseAssistClient({});
+
+        await client.logEnterInterface({
+            ticket: emptyTicket,
+        });
+
+        expect(fetchMock.called()).toBe(true);
+    });
+
+    it('should not send events when #enableAnalytics option is #false', async () => {
+        client = new CaseAssistClient({
+            enableAnalytics: false,
+        });
+
+        await client.logEnterInterface({
+            ticket: emptyTicket,
+        });
+
+        expect(fetchMock.called()).toBe(false);
+    });
+
+    it('should not send events after #disable function is called', async () => {
+        client.disable();
+
+        await client.logEnterInterface({
+            ticket: emptyTicket,
+        });
+
+        expect(fetchMock.called()).toBe(false);
+    });
+
+    it('should send events after #enable function is called', async () => {
+        client = new CaseAssistClient({
+            enableAnalytics: false,
+        });
+
+        client.enable();
+
+        await client.logEnterInterface({
+            ticket: emptyTicket,
+        });
+
+        expect(fetchMock.called()).toBe(true);
+    });
+
+    it('should send proper payload for #logEnterInterface', async () => {
+        await client.logEnterInterface({
+            ticket: emptyTicket,
+        });
+
+        expectMatchPayload(CaseAssistActions.enterInterface, noActionData, noTicket);
+    });
+
+    it('should send proper payload for #logUpdateCaseField', async () => {
+        await client.logUpdateCaseField({
+            fieldName: 'subject',
+            ticket: fakeTicket,
+        });
+
+        expectMatchPayload(CaseAssistActions.fieldUpdate, {fieldName: 'subject'}, fakeTicket);
+    });
+
+    it('should send proper payload for #logSelectFieldSuggestion', async () => {
+        await client.logSelectFieldSuggestion({
+            suggestion: fakeFieldSuggestion,
+            ticket: fakeTicket,
+        });
+
+        expectMatchPayload(CaseAssistActions.fieldSuggestionClick, fakeFieldSuggestion, fakeTicket);
+    });
+
+    it('should send proper payload for #logSelectDocumentSuggestion', async () => {
+        await client.logSelectDocumentSuggestion({
+            suggestion: fakeDocumentSuggestion,
+            ticket: fakeTicket,
+        });
+
+        expectMatchPayload(CaseAssistActions.suggestionClick, fakeDocumentSuggestion, fakeTicket);
+    });
+
+    it('should send proper payload for #logRateDocumentSuggestion', async () => {
+        const rating = 0.8;
+
+        await client.logRateDocumentSuggestion({
+            rating,
+            suggestion: fakeDocumentSuggestion,
+            ticket: fakeTicket,
+        });
+
+        expectMatchPayload(
+            CaseAssistActions.suggestionRate,
+            {
+                ...fakeDocumentSuggestion,
+                rate: rating,
+            },
+            fakeTicket
+        );
+    });
+
+    it('should send proper payload for #logMoveToNextCaseStep', async () => {
+        await client.logMoveToNextCaseStep({
+            ticket: fakeTicket,
+        });
+
+        expectMatchPayload(CaseAssistActions.nextCaseStep, noActionData, fakeTicket);
+    });
+
+    it('should send proper payload for #logCaseCancelled', async () => {
+        await client.logCaseCancelled({
+            ticket: fakeTicket,
+        });
+
+        expectMatchPayload(
+            CaseAssistActions.caseCancelled,
+            {
+                reason: CaseCancelledReasons.quit,
+            },
+            fakeTicket
+        );
+    });
+
+    it('should send proper payload for #logCaseSolved', async () => {
+        await client.logCaseSolved({
+            ticket: fakeTicket,
+        });
+
+        expectMatchPayload(
+            CaseAssistActions.caseSolved,
+            {
+                reason: CaseCancelledReasons.solved,
+            },
+            fakeTicket
+        );
+    });
+
+    it('should send proper payload for #logCaseCreated', async () => {
+        await client.logCaseCreated({
+            ticket: fakeTicket,
+        });
+
+        expectMatchPayload(CaseAssistActions.caseCreated, noActionData, fakeTicket);
+    });
+});

package/src/caseAssist/caseAssistClient.ts

@@ -0,0 +1,117 @@
+import CoveoAnalyticsClient, {AnalyticsClient, ClientOptions} from '../client/analytics';
+import {NoopAnalytics} from '../client/noopAnalytics';
+import {SVCPlugin} from '../plugins/svc';
+import {
+    CaseAssistActions,
+    CaseAssistEvents,
+    CaseCancelledMetadata,
+    CaseCancelledReasons,
+    CaseCreatedMetadata,
+    CaseSolvedMetadata,
+    EnterInterfaceMetadata,
+    MoveToNextCaseStepMetadata,
+    RateDocumentSuggestionMetadata,
+    SelectDocumentSuggestionMetadata,
+    SelectFieldSuggestionMetadata,
+    UpdateCaseFieldMetadata,
+} from './caseAssistActions';
+
+export interface CaseAssistClientOptions extends ClientOptions {
+    enableAnalytics?: boolean;
+}
+
+export class CaseAssistClient {
+    public coveoAnalyticsClient: AnalyticsClient;
+    private svc: SVCPlugin;
+
+    constructor(private options: Partial<CaseAssistClientOptions>) {
+        const analyticsEnabled = options.enableAnalytics ?? true;
+
+        this.coveoAnalyticsClient = analyticsEnabled ? new CoveoAnalyticsClient(options) : new NoopAnalytics();
+        this.svc = new SVCPlugin({client: this.coveoAnalyticsClient});
+    }
+
+    public disable() {
+        if (this.coveoAnalyticsClient instanceof CoveoAnalyticsClient) {
+            this.coveoAnalyticsClient.clear();
+        }
+        this.coveoAnalyticsClient = new NoopAnalytics();
+        this.svc = new SVCPlugin({client: this.coveoAnalyticsClient});
+    }
+
+    public enable() {
+        this.coveoAnalyticsClient = new CoveoAnalyticsClient(this.options);
+        this.svc = new SVCPlugin({client: this.coveoAnalyticsClient});
+    }
+
+    public logEnterInterface(meta: EnterInterfaceMetadata) {
+        this.svc.setAction(CaseAssistActions.enterInterface);
+        this.svc.setTicket(meta.ticket);
+        return this.sendFlowStartEvent();
+    }
+
+    public logUpdateCaseField(meta: UpdateCaseFieldMetadata) {
+        this.svc.setAction(CaseAssistActions.fieldUpdate, {
+            fieldName: meta.fieldName,
+        });
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+
+    public logSelectFieldSuggestion(meta: SelectFieldSuggestionMetadata) {
+        this.svc.setAction(CaseAssistActions.fieldSuggestionClick, meta.suggestion);
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+
+    public logSelectDocumentSuggestion(meta: SelectDocumentSuggestionMetadata) {
+        this.svc.setAction(CaseAssistActions.suggestionClick, meta.suggestion);
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+
+    public logRateDocumentSuggestion(meta: RateDocumentSuggestionMetadata) {
+        this.svc.setAction(CaseAssistActions.suggestionRate, {
+            rate: meta.rating,
+            ...meta.suggestion,
+        });
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+
+    public logMoveToNextCaseStep(meta: MoveToNextCaseStepMetadata) {
+        this.svc.setAction(CaseAssistActions.nextCaseStep);
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+
+    public logCaseCancelled(meta: CaseCancelledMetadata) {
+        this.svc.setAction(CaseAssistActions.caseCancelled, {
+            reason: CaseCancelledReasons.quit,
+        });
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+
+    public logCaseSolved(meta: CaseSolvedMetadata) {
+        this.svc.setAction(CaseAssistActions.caseSolved, {
+            reason: CaseCancelledReasons.solved,
+        });
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+
+    public logCaseCreated(meta: CaseCreatedMetadata) {
+        this.svc.setAction(CaseAssistActions.caseCreated);
+        this.svc.setTicket(meta.ticket);
+        return this.sendClickEvent();
+    }
+
+    private sendFlowStartEvent() {
+        return this.coveoAnalyticsClient.sendEvent('event', 'svc', CaseAssistEvents.flowStart);
+    }
+
+    private sendClickEvent() {
+        return this.coveoAnalyticsClient.sendEvent('event', 'svc', CaseAssistEvents.click);
+    }
+}

package/src/client/measurementProtocolMapping/baseMeasurementProtocolMapper.ts

@@ -34,8 +34,17 @@ const contextInformationMapping: {[key in keyof DefaultContextInformation]: stri
     time: 'tm',
 };
 
-/* Those are extension keys that are supported by the collect protocol. They will be forwarded as-is. */
-const coveoExtensionsKeys = ['contentId', 'contentIdKey', 'contentType'];
+/* Those are extension keys that are supported by the Coveo collect protocol (but not Google's protocol). They will be forwarded as-is. */
+const coveoExtensionsKeys = [
+    'contentId',
+    'contentIdKey',
+    'contentType',
+    'searchHub',
+    'tab',
+    'searchUid',
+    'permanentId',
+    'contentLocale',
+];
 
 export const baseMeasurementProtocolKeysMapping: {[name: string]: string} = {
     ...globalParamKeysMapping,

package/src/coveoua/headless.ts

@@ -1,4 +1,5 @@
 export {CoveoSearchPageClient, SearchPageClientProvider} from '../searchPage/searchPageClient';
+export {CaseAssistClient} from '../caseAssist/caseAssistClient';
 export {CoveoAnalyticsClient, AnalyticsClientSendEventHook} from '../client/analytics';
 export {PreprocessAnalyticsRequest} from '../client/analyticsRequestClient';
 export * as history from '../history';

package/src/coveoua/library.ts

@@ -8,5 +8,6 @@ export {PreprocessAnalyticsRequest} from '../client/analyticsRequestClient';
 export {IRuntimeEnvironment} from '../client/runtimeEnvironment';
 export {CoveoUA, getCurrentClient, handleOneAnalyticsEvent} from './simpleanalytics';
 export {CoveoSearchPageClient, SearchPageClientProvider} from '../searchPage/searchPageClient';
+export {CaseAssistClient} from '../caseAssist/caseAssistClient';
 
 export {analytics, donottrack, history, SimpleAnalytics, storage};

package/src/detector.ts

@@ -11,11 +11,19 @@ export function hasDocument(): boolean {
 }
 
 export function hasLocalStorage(): boolean {
-    return typeof localStorage !== 'undefined';
+    try {
+        return typeof localStorage !== 'undefined';
+    } catch (error) {
+        return false;
+    }
 }
 
 export function hasSessionStorage(): boolean {
-    return typeof sessionStorage !== 'undefined';
+    try {
+        return typeof sessionStorage !== 'undefined';
+    } catch (error) {
+        return false;
+    }
 }
 
 export function hasCookieStorage(): boolean {

package/src/plugins/BasePlugin.ts

@@ -97,12 +97,11 @@ export abstract class BasePlugin {
 
         if (eventType === BasePluginEventTypes.pageview) {
             this.nextPageViewId = this.uuidGenerator();
+            this.hasSentFirstPageView = true;
         }
-
-        this.hasSentFirstPageView = true;
     }
 
-    /* 
+    /*
         When calling getPayload or getParameters, we need to return what would be sent by the API without updating our internal reference. 
         For instance, if you getPayload("pageview"), we want to return the same payload as if you did coveoua("send", "pageview").
     */