coveo.analytics 2.20.24 → 2.20.26

package/src/insight/insightClient.ts

@@ -2,22 +2,22 @@ import CoveoAnalyticsClient, {AnalyticsClient, ClientOptions} from '../client/an
 import {NoopAnalytics} from '../client/noopAnalytics';
 import doNotTrack from '../donottrack';
 import {CustomEventRequest, SearchEventRequest} from '../events';
+import {CustomEventsTypes, FacetStateMetadata, SearchPageEvents} from '../searchPage/searchPageEvents';
 import {
-    CustomEventsTypes,
-    FacetBaseMeta,
-    FacetMetadata,
-    FacetSortMeta,
-    FacetStateMetadata,
-    PagerMetadata,
-    InterfaceChangeMetadata,
-    QueryErrorMeta,
-    SearchPageEvents,
-    ResultsSortMetadata,
-    FacetRangeMetadata,
-    CategoryFacetMetadata,
-    StaticFilterToggleValueMetadata,
-} from '../searchPage/searchPageEvents';
-import {ContextChangedMetadata, ExpandToFullUIMetadata, InsightEvents} from './insightEvents';
+    ExpandToFullUIMetadata,
+    InsightEvents,
+    InsightFacetMetadata,
+    InsightInterfaceChangeMetadata,
+    InsightStaticFilterToggleValueMetadata,
+    InsightFacetRangeMetadata,
+    InsightCategoryFacetMetadata,
+    CaseMetadata,
+    InsightFacetSortMeta,
+    InsightFacetBaseMeta,
+    InsightQueryErrorMeta,
+    InsightPagerMetadata,
+    InsightResultsSortMetadata,
+} from './insightEvents';
 
 export interface InsightClientProvider {
     getSearchEventRequestPayload: () => Omit<SearchEventRequest, 'actionCause' | 'searchQueryUid'>;
@@ -37,16 +37,33 @@ export interface InsightClientOptions extends ClientOptions {
     enableAnalytics: boolean;
 }
 
-const extractContextFromMetadata = (meta: {caseContext: Record<string, string>}) => {
+const extractContextFromMetadata = (meta: {caseContext?: Record<string, string>}) => {
     const context: Record<string, string> = {};
-    Object.keys(meta.caseContext).forEach((contextKey) => {
-        const keyToBeSent = `context_${contextKey}`;
-        context[keyToBeSent] = meta.caseContext[contextKey];
-    });
-
+    if (meta.caseContext) {
+        Object.keys(meta.caseContext).forEach((contextKey) => {
+            const value = meta.caseContext?.[contextKey];
+            if (value) {
+                const keyToBeSent = `context_${contextKey}`;
+                context[keyToBeSent] = value;
+            }
+        });
+    }
     return context;
 };
 
+const generateMetadataToSend = (metadata: CaseMetadata, includeContext = true) => {
+    const {caseContext, caseId, caseNumber, ...metadataWithoutContext} = metadata;
+    const context = extractContextFromMetadata(metadata);
+
+    return {
+        CaseId: caseId,
+        CaseNumber: caseNumber,
+        ...metadataWithoutContext,
+        ...(!!context.context_Case_Subject && {CaseSubject: context.context_Case_Subject}),
+        ...(includeContext && context),
+    };
+};
+
 export class CoveoInsightClient {
     public coveoAnalyticsClient: AnalyticsClient;
 
@@ -66,127 +83,150 @@ export class CoveoInsightClient {
         this.coveoAnalyticsClient = new CoveoAnalyticsClient(this.opts);
     }
 
-    public logInterfaceLoad() {
+    public logInterfaceLoad(metadata?: CaseMetadata) {
+        if (metadata) {
+            const metadataToSend = generateMetadataToSend(metadata);
+            return this.logSearchEvent(SearchPageEvents.interfaceLoad, metadataToSend);
+        }
         return this.logSearchEvent(SearchPageEvents.interfaceLoad);
     }
 
-    public logInterfaceChange(metadata: InterfaceChangeMetadata) {
-        return this.logSearchEvent(SearchPageEvents.interfaceChange, metadata);
+    public logInterfaceChange(metadata: InsightInterfaceChangeMetadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(SearchPageEvents.interfaceChange, metadataToSend);
     }
 
-    public logStaticFilterDeselect(meta: StaticFilterToggleValueMetadata) {
-        return this.logSearchEvent(SearchPageEvents.staticFilterDeselect, meta);
+    public logStaticFilterDeselect(metadata: InsightStaticFilterToggleValueMetadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(SearchPageEvents.staticFilterDeselect, metadataToSend);
     }
 
-    public logFetchMoreResults() {
+    public logFetchMoreResults(metadata?: CaseMetadata) {
+        if (metadata) {
+            const metadataToSend = generateMetadataToSend(metadata);
+            return this.logCustomEvent(SearchPageEvents.pagerScrolling, {...metadataToSend, type: 'getMoreResults'});
+        }
         return this.logCustomEvent(SearchPageEvents.pagerScrolling, {type: 'getMoreResults'});
     }
 
-    public logBreadcrumbFacet(metadata: FacetMetadata | FacetRangeMetadata | CategoryFacetMetadata) {
-        return this.logSearchEvent(SearchPageEvents.breadcrumbFacet, metadata);
+    public logBreadcrumbFacet(
+        metadata: InsightFacetMetadata | InsightFacetRangeMetadata | InsightCategoryFacetMetadata
+    ) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(SearchPageEvents.breadcrumbFacet, metadataToSend);
     }
 
-    public logBreadcrumbResetAll() {
+    public logBreadcrumbResetAll(metadata?: CaseMetadata) {
+        if (metadata) {
+            const metadataToSend = generateMetadataToSend(metadata);
+            return this.logSearchEvent(SearchPageEvents.breadcrumbResetAll, metadataToSend);
+        }
         return this.logSearchEvent(SearchPageEvents.breadcrumbResetAll);
     }
 
-    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 logFacetSelect(metadata: InsightFacetMetadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(SearchPageEvents.facetSelect, metadataToSend);
     }
 
-    public logFacetClearAll(meta: FacetBaseMeta) {
-        return this.logSearchEvent(SearchPageEvents.facetClearAll, meta);
+    public logFacetDeselect(metadata: InsightFacetMetadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(SearchPageEvents.facetDeselect, metadataToSend);
     }
 
-    public logFacetShowMore(meta: FacetBaseMeta) {
-        return this.logCustomEvent(SearchPageEvents.facetShowMore, meta);
+    public logFacetUpdateSort(metadata: InsightFacetSortMeta) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(SearchPageEvents.facetUpdateSort, metadataToSend);
     }
 
-    public logFacetShowLess(meta: FacetBaseMeta) {
-        return this.logCustomEvent(SearchPageEvents.facetShowLess, meta);
+    public logFacetClearAll(metadata: InsightFacetBaseMeta) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(SearchPageEvents.facetClearAll, metadataToSend);
     }
 
-    public logQueryError(meta: QueryErrorMeta) {
-        return this.logCustomEvent(SearchPageEvents.queryError, meta);
+    public logFacetShowMore(metadata: InsightFacetBaseMeta) {
+        const metadataToSend = generateMetadataToSend(metadata, false);
+        return this.logCustomEvent(SearchPageEvents.facetShowMore, metadataToSend);
     }
 
-    public async logCustomEvent(event: SearchPageEvents | InsightEvents, 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 logFacetShowLess(metadata: InsightFacetBaseMeta) {
+        const metadataToSend = generateMetadataToSend(metadata, false);
+        return this.logCustomEvent(SearchPageEvents.facetShowLess, metadataToSend);
     }
 
-    public async logSearchEvent(event: SearchPageEvents | InsightEvents, metadata?: Record<string, any>) {
-        return this.coveoAnalyticsClient.sendSearchEvent(await this.getBaseSearchEventRequest(event, metadata));
+    public logQueryError(metadata: InsightQueryErrorMeta) {
+        const metadataToSend = generateMetadataToSend(metadata, false);
+        return this.logCustomEvent(SearchPageEvents.queryError, metadataToSend);
     }
 
-    public logPagerNumber(meta: PagerMetadata) {
-        return this.logCustomEvent(SearchPageEvents.pagerNumber, meta);
+    public logPagerNumber(metadata: InsightPagerMetadata) {
+        const metadataToSend = generateMetadataToSend(metadata, false);
+        return this.logCustomEvent(SearchPageEvents.pagerNumber, metadataToSend);
     }
 
-    public logPagerNext(meta: PagerMetadata) {
-        return this.logCustomEvent(SearchPageEvents.pagerNext, meta);
+    public logPagerNext(metadata: InsightPagerMetadata) {
+        const metadataToSend = generateMetadataToSend(metadata, false);
+        return this.logCustomEvent(SearchPageEvents.pagerNext, metadataToSend);
     }
 
-    public logPagerPrevious(meta: PagerMetadata) {
-        return this.logCustomEvent(SearchPageEvents.pagerPrevious, meta);
+    public logPagerPrevious(metadata: InsightPagerMetadata) {
+        const metadataToSend = generateMetadataToSend(metadata, false);
+        return this.logCustomEvent(SearchPageEvents.pagerPrevious, metadataToSend);
     }
 
-    public logDidYouMeanAutomatic() {
+    public logDidYouMeanAutomatic(metadata?: CaseMetadata) {
+        if (metadata) {
+            const metadataToSend = generateMetadataToSend(metadata);
+            return this.logSearchEvent(SearchPageEvents.didyoumeanAutomatic, metadataToSend);
+        }
         return this.logSearchEvent(SearchPageEvents.didyoumeanAutomatic);
     }
 
-    public logDidYouMeanClick() {
+    public logDidYouMeanClick(metadata?: CaseMetadata) {
+        if (metadata) {
+            const metadataToSend = generateMetadataToSend(metadata);
+            return this.logSearchEvent(SearchPageEvents.didyoumeanClick, metadataToSend);
+        }
         return this.logSearchEvent(SearchPageEvents.didyoumeanClick);
     }
 
-    public logResultsSort(metadata: ResultsSortMetadata) {
-        return this.logSearchEvent(SearchPageEvents.resultsSort, metadata);
+    public logResultsSort(metadata: InsightResultsSortMetadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(SearchPageEvents.resultsSort, metadataToSend);
     }
 
-    public logSearchboxSubmit() {
+    public logSearchboxSubmit(metadata?: CaseMetadata) {
+        if (metadata) {
+            const metadataToSend = generateMetadataToSend(metadata);
+            return this.logSearchEvent(SearchPageEvents.searchboxSubmit, metadataToSend);
+        }
         return this.logSearchEvent(SearchPageEvents.searchboxSubmit);
     }
 
-    public logContextChanged(meta: ContextChangedMetadata) {
-        const context = extractContextFromMetadata(meta);
+    public logContextChanged(metadata: CaseMetadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logSearchEvent(InsightEvents.contextChanged, metadataToSend);
+    }
 
-        const {caseId, caseNumber} = meta;
-        const metaToBeSent = {
-            CaseId: caseId,
-            CaseNumber: caseNumber,
-            ...(!!context.context_Case_Subject && {CaseSubject: context.context_Case_Subject}),
-            ...context,
-        };
-        return this.logSearchEvent(InsightEvents.contextChanged, metaToBeSent);
+    public logExpandToFullUI(metadata: ExpandToFullUIMetadata) {
+        const metadataToSend = generateMetadataToSend(metadata);
+        return this.logCustomEvent(InsightEvents.expandToFullUI, metadataToSend);
     }
 
-    public logExpandToFullUI(meta: ExpandToFullUIMetadata) {
-        const context = extractContextFromMetadata(meta);
+    public async logCustomEvent(event: SearchPageEvents | InsightEvents, metadata?: Record<string, any>) {
+        const customData = {...this.provider.getBaseMetadata(), ...metadata};
 
-        const {caseId, caseNumber, triggeredBy, fullSearchComponentName} = meta;
-        const metaToBeSent = {
-            CaseId: caseId,
-            CaseNumber: caseNumber,
-            triggeredBy,
-            fullSearchComponentName,
-            ...(!!context.context_Case_Subject && {CaseSubject: context.context_Case_Subject}),
+        const payload: CustomEventRequest = {
+            ...(await this.getBaseCustomEventRequest(customData)),
+            eventType: CustomEventsTypes[event]!,
+            eventValue: event,
         };
-        return this.logCustomEvent(InsightEvents.expandToFullUI, metaToBeSent);
+
+        return this.coveoAnalyticsClient.sendCustomEvent(payload);
+    }
+
+    public async logSearchEvent(event: SearchPageEvents | InsightEvents, metadata?: Record<string, any>) {
+        return this.coveoAnalyticsClient.sendSearchEvent(await this.getBaseSearchEventRequest(event, metadata));
     }
 
     private async getBaseCustomEventRequest(metadata?: Record<string, any>) {

package/src/insight/insightEvents.ts

@@ -1,3 +1,16 @@
+import {
+    CategoryFacetMetadata,
+    FacetBaseMeta,
+    FacetMetadata,
+    FacetRangeMetadata,
+    FacetSortMeta,
+    InterfaceChangeMetadata,
+    PagerMetadata,
+    QueryErrorMeta,
+    ResultsSortMetadata,
+    StaticFilterToggleValueMetadata,
+} from '../searchPage/searchPageEvents';
+
 export enum InsightEvents {
     /**
      * Identifies the search event that gets logged when the query context is updated as a result of updating one of the case context fields.
@@ -9,15 +22,33 @@ export enum InsightEvents {
     expandToFullUI = 'expandToFullUI',
 }
 
-interface CaseMetadata {
-    caseId: string;
-    caseNumber: string;
-    caseContext: Record<string, string>;
+export interface CaseMetadata {
+    caseId?: string;
+    caseNumber?: string;
+    caseContext?: Record<string, string>;
 }
 
-export interface ContextChangedMetadata extends CaseMetadata {}
-
 export interface ExpandToFullUIMetadata extends CaseMetadata {
     fullSearchComponentName: string;
     triggeredBy: string;
 }
+
+export interface InsightInterfaceChangeMetadata extends InterfaceChangeMetadata, CaseMetadata {}
+
+export interface InsightFacetMetadata extends FacetMetadata, CaseMetadata {}
+
+export interface InsightStaticFilterToggleValueMetadata extends StaticFilterToggleValueMetadata, CaseMetadata {}
+
+export interface InsightFacetRangeMetadata extends FacetRangeMetadata, CaseMetadata {}
+
+export interface InsightCategoryFacetMetadata extends CategoryFacetMetadata, CaseMetadata {}
+
+export interface InsightFacetSortMeta extends FacetSortMeta, CaseMetadata {}
+
+export interface InsightFacetBaseMeta extends FacetBaseMeta, CaseMetadata {}
+
+export interface InsightQueryErrorMeta extends QueryErrorMeta, CaseMetadata {}
+
+export interface InsightPagerMetadata extends PagerMetadata, CaseMetadata {}
+
+export interface InsightResultsSortMetadata extends ResultsSortMetadata, CaseMetadata {}