coveo.analytics 2.23.6 → 2.23.8

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "coveo.analytics",
-    "version": "2.23.6",
+    "version": "2.23.8",
     "description": "📈 Coveo analytics client (node and browser compatible) ",
     "main": "dist/library.js",
     "module": "dist/library.es.js",

package/src/client/analytics.ts

@@ -13,6 +13,10 @@ import {
     VisitResponse,
     IRequestPayload,
     VariableArgumentsPayload,
+    PreparedClickEventRequest,
+    PreparedCustomEventRequest,
+    PreparedViewEventRequest,
+    PreparedSearchEventRequest,
 } from '../events';
 import {IAnalyticsClientOptions, PreprocessAnalyticsRequest, VisitorIdProvider} from './analyticsRequestClient';
 import {hasWindow, hasDocument} from '../detector';
@@ -58,13 +62,34 @@ export type EventTypeConfig = {
     usesMeasurementProtocol?: boolean;
 };
 
+export interface PreparedEvent<TPreparedRequest, TCompleteRequest, TResponse extends AnyEventResponse>
+    extends BufferedRequest {
+    log(remainingPayload: Omit<TCompleteRequest, keyof TPreparedRequest>): Promise<TResponse | void>;
+}
+
 export interface AnalyticsClient {
     getPayload(eventType: string, ...payload: VariableArgumentsPayload): Promise<any>;
     getParameters(eventType: string, ...payload: VariableArgumentsPayload): Promise<any>;
+    makeEvent<TPreparedRequest, TCompleteRequest, TResponse extends AnyEventResponse>(
+        eventType: string,
+        ...payload: VariableArgumentsPayload
+    ): Promise<PreparedEvent<TPreparedRequest, TCompleteRequest, TResponse>>;
     sendEvent(eventType: string, ...payload: VariableArgumentsPayload): Promise<AnyEventResponse | void>;
+    makeSearchEvent(
+        request: PreparedSearchEventRequest
+    ): Promise<PreparedEvent<PreparedSearchEventRequest, SearchEventRequest, SearchEventResponse>>;
     sendSearchEvent(request: SearchEventRequest): Promise<SearchEventResponse | void>;
+    makeClickEvent(
+        request: PreparedClickEventRequest
+    ): Promise<PreparedEvent<PreparedClickEventRequest, ClickEventRequest, ClickEventResponse>>;
     sendClickEvent(request: ClickEventRequest): Promise<ClickEventResponse | void>;
+    makeCustomEvent(
+        request: PreparedCustomEventRequest
+    ): Promise<PreparedEvent<PreparedCustomEventRequest, CustomEventRequest, CustomEventResponse>>;
     sendCustomEvent(request: CustomEventRequest): Promise<CustomEventResponse | void>;
+    makeViewEvent(
+        request: PreparedViewEventRequest
+    ): Promise<PreparedEvent<PreparedViewEventRequest, ViewEventRequest, ViewEventResponse>>;
     sendViewEvent(request: ViewEventRequest): Promise<ViewEventResponse | void>;
     getVisit(): Promise<VisitResponse>;
     getHealth(): Promise<HealthResponse>;
@@ -285,25 +310,34 @@ export class CoveoAnalyticsClient implements AnalyticsClient, VisitorIdProvider
         return payloadToSend;
     }
 
-    async sendEvent(
+    async makeEvent<TPreparedRequest, TCompleteRequest, TResponse extends AnyEventResponse>(
         eventType: EventType | string,
         ...payload: VariableArgumentsPayload
-    ): Promise<AnyEventResponse | void> {
+    ): Promise<PreparedEvent<TPreparedRequest, TCompleteRequest, TResponse>> {
         const {newEventType: eventTypeToSend = eventType as EventType} = this.eventTypeMapping[eventType] || {};
 
         const parametersToSend = await this.resolveParameters(eventType, ...payload);
         const payloadToSend = await this.resolvePayloadForParameters(eventType, parametersToSend);
 
-        this.bufferedRequests.push({
+        return {
             eventType: eventTypeToSend,
             payload: payloadToSend,
-        });
-
-        await Promise.all(this.afterSendHooks.map((hook) => hook(eventType, parametersToSend)));
-
-        await this.deferExecution();
+            log: async (remainingPayload) => {
+                this.bufferedRequests.push(<BufferedRequest>{
+                    eventType: eventTypeToSend,
+                    payload: {...payloadToSend, ...remainingPayload},
+                });
+                await Promise.all(
+                    this.afterSendHooks.map((hook) => hook(eventType, {...parametersToSend, ...remainingPayload}))
+                );
+                await this.deferExecution();
+                return (await this.sendFromBufferWithFetch()) as TResponse | void;
+            },
+        };
+    }
 
-        return await this.sendFromBufferWithFetch();
+    async sendEvent(eventType: EventType | string, ...payload: VariableArgumentsPayload) {
+        return (await this.makeEvent<any, any, AnyEventResponse>(eventType, ...payload)).log({});
     }
 
     private deferExecution(): Promise<void> {
@@ -328,20 +362,45 @@ export class CoveoAnalyticsClient implements AnalyticsClient, VisitorIdProvider
         this.runtime.client.deleteHttpCookieVisitorId();
     }
 
-    async sendSearchEvent(request: SearchEventRequest): Promise<SearchEventResponse | void> {
-        return this.sendEvent(EventType.search, request);
+    async makeSearchEvent(request: PreparedSearchEventRequest) {
+        return this.makeEvent<PreparedSearchEventRequest, SearchEventRequest, SearchEventResponse>(
+            EventType.search,
+            request
+        );
+    }
+
+    async sendSearchEvent({searchQueryUid, ...preparedRequest}: SearchEventRequest) {
+        return (await this.makeSearchEvent(preparedRequest)).log({searchQueryUid});
+    }
+
+    async makeClickEvent(request: PreparedClickEventRequest) {
+        return this.makeEvent<PreparedClickEventRequest, ClickEventRequest, ClickEventResponse>(
+            EventType.click,
+            request
+        );
+    }
+
+    async sendClickEvent({searchQueryUid, ...preparedRequest}: ClickEventRequest) {
+        return (await this.makeClickEvent(preparedRequest)).log({searchQueryUid});
+    }
+
+    async makeCustomEvent(request: PreparedCustomEventRequest) {
+        return this.makeEvent<PreparedCustomEventRequest, CustomEventRequest, CustomEventResponse>(
+            EventType.custom,
+            request
+        );
     }
 
-    async sendClickEvent(request: ClickEventRequest): Promise<ClickEventResponse | void> {
-        return this.sendEvent(EventType.click, request);
+    async sendCustomEvent({lastSearchQueryUid, ...preparedRequest}: CustomEventRequest) {
+        return (await this.makeCustomEvent(preparedRequest)).log({lastSearchQueryUid});
     }
 
-    async sendCustomEvent(request: CustomEventRequest): Promise<CustomEventResponse | void> {
-        return this.sendEvent(EventType.custom, request);
+    async makeViewEvent(request: PreparedViewEventRequest) {
+        return this.makeEvent<PreparedViewEventRequest, ViewEventRequest, ViewEventResponse>(EventType.view, request);
     }
 
     async sendViewEvent(request: ViewEventRequest): Promise<ViewEventResponse | void> {
-        return this.sendEvent(EventType.view, request);
+        return (await this.makeViewEvent(request)).log({});
     }
 
     async getVisit(): Promise<VisitResponse> {

package/src/client/noopAnalytics.ts

@@ -1,4 +1,4 @@
-import {AnalyticsClient} from './analytics';
+import {AnalyticsClient, PreparedEvent} from './analytics';
 import {
     AnyEventResponse,
     SearchEventResponse,
@@ -7,6 +7,15 @@ import {
     VisitResponse,
     HealthResponse,
     ViewEventResponse,
+    EventType,
+    PreparedSearchEventRequest,
+    SearchEventRequest,
+    ClickEventRequest,
+    CustomEventRequest,
+    PreparedClickEventRequest,
+    PreparedCustomEventRequest,
+    PreparedViewEventRequest,
+    ViewEventRequest,
 } from '../events';
 import {NoopRuntime} from './runtimeEnvironment';
 
@@ -17,18 +26,35 @@ export class NoopAnalytics implements AnalyticsClient {
     getParameters(): Promise<any> {
         return Promise.resolve();
     }
+    makeEvent<TPreparedRequest, TCompleteRequest, TResponse extends AnyEventResponse>(
+        eventType: EventType | string
+    ): Promise<PreparedEvent<TPreparedRequest, TCompleteRequest, TResponse>> {
+        return Promise.resolve({eventType: eventType as EventType, payload: null, log: () => Promise.resolve()});
+    }
     sendEvent(): Promise<AnyEventResponse | void> {
         return Promise.resolve();
     }
+    makeSearchEvent() {
+        return this.makeEvent<PreparedSearchEventRequest, SearchEventRequest, SearchEventResponse>(EventType.search);
+    }
     sendSearchEvent(): Promise<SearchEventResponse | void> {
         return Promise.resolve();
     }
+    makeClickEvent() {
+        return this.makeEvent<PreparedClickEventRequest, ClickEventRequest, ClickEventResponse>(EventType.click);
+    }
     sendClickEvent(): Promise<ClickEventResponse | void> {
         return Promise.resolve();
     }
+    makeCustomEvent() {
+        return this.makeEvent<PreparedCustomEventRequest, CustomEventRequest, CustomEventResponse>(EventType.custom);
+    }
     sendCustomEvent(): Promise<CustomEventResponse | void> {
         return Promise.resolve();
     }
+    makeViewEvent() {
+        return this.makeEvent<PreparedViewEventRequest, ViewEventRequest, ViewEventResponse>(EventType.view);
+    }
     sendViewEvent(): Promise<ViewEventResponse | void> {
         return Promise.resolve();
     }

package/src/events.ts

@@ -68,6 +68,8 @@ export interface SearchEventRequest extends EventBaseRequest {
     facetState?: FacetStateRequest[];
 }
 
+export interface PreparedSearchEventRequest extends Omit<SearchEventRequest, 'searchQueryUid'> {}
+
 export interface DocumentInformation {
     documentUri: string;
     documentUriHash: string;
@@ -86,12 +88,16 @@ export interface DocumentInformation {
 
 export interface ClickEventRequest extends EventBaseRequest, DocumentInformation {}
 
+export interface PreparedClickEventRequest extends Omit<ClickEventRequest, 'searchQueryUid'> {}
+
 export interface CustomEventRequest extends EventBaseRequest {
     eventType: string;
     eventValue: string;
     lastSearchQueryUid?: string;
 }
 
+export interface PreparedCustomEventRequest extends Omit<CustomEventRequest, 'lastSearchQueryUid'> {}
+
 export interface ViewEventRequest extends EventBaseRequest {
     location?: string;
     referrer?: string;
@@ -101,6 +107,8 @@ export interface ViewEventRequest extends EventBaseRequest {
     contentType?: string;
 }
 
+export interface PreparedViewEventRequest extends ViewEventRequest {}
+
 export interface DefaultEventResponse {
     visitId: string;
     visitorId: string;

package/src/insight/insightClient.spec.ts

@@ -333,6 +333,25 @@ describe('InsightClient', () => {
             await client.logDocumentQuickview(fakeDocInfo, fakeDocID);
             expectMatchDocumentPayload(SearchPageEvents.documentQuickview, fakeDocInfo, expectedMetadata);
         });
+
+        it('should send proper payload for #caseAttach', async () => {
+            const expectedMetadata = {
+                ...fakeDocID,
+                documentTitle: fakeDocInfo.documentTitle,
+                documentURL: fakeDocInfo.documentUrl,
+                resultUriHash: fakeDocInfo.documentUriHash,
+            };
+            await client.logCaseAttach(fakeDocInfo, fakeDocID);
+            expectMatchDocumentPayload(SearchPageEvents.caseAttach, fakeDocInfo, expectedMetadata);
+        });
+
+        it('should send proper payload for #caseDetach', async () => {
+            const expectedMetadata = {
+                resultUriHash: fakeDocInfo.documentUriHash,
+            };
+            await client.logCaseDetach(fakeDocInfo.documentUriHash);
+            expectMatchCustomEventPayload(SearchPageEvents.caseDetach, expectedMetadata);
+        });
     });
 
     describe('when the case metadata is included', () => {
@@ -714,6 +733,31 @@ describe('InsightClient', () => {
             await client.logDocumentQuickview(fakeDocInfo, fakeDocID, metadata);
             expectMatchDocumentPayload(SearchPageEvents.documentQuickview, fakeDocInfo, expectedMetadata);
         });
+
+        it('should send proper payload for #caseAttach', async () => {
+            const metadata = baseCaseMetadata;
+
+            const expectedMetadata = {
+                ...fakeDocID,
+                ...expectedBaseCaseMetadata,
+                documentTitle: fakeDocInfo.documentTitle,
+                documentURL: fakeDocInfo.documentUrl,
+                resultUriHash: fakeDocInfo.documentUriHash,
+            };
+            await client.logCaseAttach(fakeDocInfo, fakeDocID, metadata);
+            expectMatchDocumentPayload(SearchPageEvents.caseAttach, fakeDocInfo, expectedMetadata);
+        });
+
+        it('should send proper payload for #caseDetach', async () => {
+            const metadata = baseCaseMetadata;
+
+            const expectedMetadata = {
+                ...expectedBaseCaseMetadata,
+                resultUriHash: fakeDocInfo.documentUriHash,
+            };
+            await client.logCaseDetach(fakeDocInfo.documentUriHash, metadata);
+            expectMatchCustomEventPayload(SearchPageEvents.caseDetach, expectedMetadata);
+        });
     });
 
     it('should enable analytics tracking by default', () => {

package/src/insight/insightClient.ts

@@ -258,6 +258,32 @@ export class CoveoInsightClient {
         );
     }
 
+    public logCaseAttach(
+        info: PartialDocumentInformation,
+        identifier: DocumentIdentifier,
+        caseMetadata?: CaseMetadata
+    ) {
+        const metadata = {
+            documentTitle: info.documentTitle,
+            documentURL: info.documentUrl,
+            resultUriHash: info.documentUriHash,
+        };
+
+        return this.logClickEvent(
+            SearchPageEvents.caseAttach,
+            info,
+            identifier,
+            caseMetadata ? {...generateMetadataToSend(caseMetadata, false), ...metadata} : metadata
+        );
+    }
+
+    public logCaseDetach(resultUriHash: string, metadata?: CaseMetadata) {
+        return this.logCustomEvent(
+            SearchPageEvents.caseDetach,
+            metadata ? {...generateMetadataToSend(metadata, false), resultUriHash} : {resultUriHash}
+        );
+    }
+
     public async logCustomEvent(event: SearchPageEvents | InsightEvents, metadata?: Record<string, any>) {
         const customData = {...this.provider.getBaseMetadata(), ...metadata};