@simplybusiness/services 0.20.0 → 0.21.0

package/src/snowplow/contexts.test.ts

@@ -1,5 +1,5 @@
 import { pageData } from "../mocks/scripts-mock";
-import { getContexts } from "./contexts";
+import { getContexts, makeContexts, updateIdentityContext } from "./contexts";
 import { getSnowplowConfig } from "./getSnowplowConfig";
 import { PageDataProps, TrackingProps } from "./types";
 
@@ -7,9 +7,15 @@ describe("Snowplow Contexts", () => {
   it("should extract all context records from snowplow props", () => {
     const snowplowProps = getSnowplowConfig(pageData as PageDataProps);
     const contexts = getContexts(snowplowProps as TrackingProps);
+    const keys = Object.keys(contexts);
 
-    expect(contexts).toHaveLength(3);
-    expect(contexts[0]).toEqual({
+    expect(keys).toEqual([
+      "pageViewContext",
+      "distributionChannelContext",
+      "serviceChannelContext",
+    ]);
+
+    expect(contexts["pageViewContext"]).toEqual({
       schema: "iglu:uk.co.simplybusiness/journey_context/jsonschema/1-0-0",
       data: {
         site: "simplybusiness_us",
@@ -22,14 +28,136 @@ describe("Snowplow Contexts", () => {
         page_step_depth: -1,
       },
     });
-    expect(contexts[1]).toEqual({
+
+    expect(contexts["distributionChannelContext"]).toEqual({
       schema:
         "iglu:com.simplybusiness/distribution_channel_context/jsonschema/1-0-0",
       data: { service_channel_identifier: "simplybusiness_us" },
     });
-    expect(contexts[2]).toEqual({
-      schema: "iglu:com.simplybusiness/service_channel_context/jsonschema/1-0-0",
+
+    expect(contexts["serviceChannelContext"]).toEqual({
+      schema:
+        "iglu:com.simplybusiness/service_channel_context/jsonschema/1-0-0",
       data: { service_channel_identifier: "simplybusiness_us" },
     });
   });
+
+  it("should extract empty contexts when config is null", () => {
+    const contexts = getContexts(null as unknown as TrackingProps);
+    expect(Object.keys(contexts)).toEqual([]);
+  });
+
+  it("should handle primitive values in context", () => {
+    const props = {
+      someContext: "primitive-value",
+    } as unknown as TrackingProps;
+
+    const contexts = getContexts(props);
+    expect(contexts["someContext"]).toEqual({
+      data: { service_channel_identifier: "primitive-value" },
+    });
+  });
+
+  describe("makeContexts", () => {
+    it("should return only the contexts that are present in the keys", () => {
+      const contexts = {
+        context1: {
+          schema: "iglu:com.simplybusiness/context1/jsonschema/1-0-0",
+          data: {
+            some_field: "some_value",
+          },
+        },
+        context2: {
+          schema: "iglu:com.simplybusiness/context2/jsonschema/1-0-0",
+          data: {
+            some_field: "some_value",
+          },
+        },
+      };
+
+      const keys = ["context1"];
+      const result = makeContexts(keys, contexts);
+
+      expect(result).toEqual([contexts.context1]);
+    });
+
+    it("should return multiple contexts if present in the keys", () => {
+      const contexts = {
+        context1: {
+          schema: "iglu:com.simplybusiness/context1/jsonschema/1-0-0",
+          data: {
+            some_field: "some_value",
+          },
+        },
+        context2: {
+          schema: "iglu:com.simplybusiness/context2/jsonschema/1-0-0",
+          data: {
+            some_field: "some_value",
+          },
+        },
+      };
+
+      const keys = ["context1", "context2"];
+      const result = makeContexts(keys, contexts);
+
+      expect(result).toEqual([contexts.context1, contexts.context2]);
+    });
+
+    it("should return an empty object when no contexts are present in the keys", () => {
+      const contexts = {
+        context1: {
+          schema: "iglu:com.simplybusiness/context1/jsonschema/1-0-0",
+          data: {
+            some_field: "some_value",
+          },
+        },
+        context2: {
+          schema: "iglu:com.simplybusiness/context2/jsonschema/1-0-0",
+          data: {
+            some_field: "some_value",
+          },
+        },
+      };
+
+      const result = makeContexts([], contexts);
+
+      expect(Object.keys(result)).toEqual([]);
+    });
+  });
+
+  describe("updateIdentityContext", () => {
+    it("should update the domain_userid when identity context exists", () => {
+      const contexts = {
+        identityContext: {
+          schema: "iglu:uk.co.simplybusiness/identity_context/jsonschema/1-0-0",
+          data: {
+            user_id: "123",
+            domain_userid: "old-uid",
+          },
+        },
+      };
+
+      const updatedContexts = updateIdentityContext(contexts, "new-uid");
+
+      expect(updatedContexts.identityContext.data.domain_userid).toEqual(
+        "new-uid",
+      );
+      expect(updatedContexts.identityContext.data.user_id).toEqual("123");
+    });
+
+    it("should return the original contexts when identity context doesn't exist", () => {
+      const contexts = {
+        someOtherContext: {
+          schema: "iglu:uk.co.simplybusiness/other_context/jsonschema/1-0-0",
+          data: {
+            some_field: "some_value",
+          },
+        },
+      };
+
+      const updatedContexts = updateIdentityContext(contexts, "new-uid");
+
+      expect(updatedContexts).toEqual(contexts);
+    });
+  });
 });

package/src/snowplow/contexts.ts

@@ -1,20 +1,50 @@
-import { SelfDescribingJson } from "@snowplow/browser-tracker";
-import { TrackingProps } from "./types";
 import { snakeCaseKeys } from "../utils";
+import { SerialisedEvent, TrackingProps } from "./types";
 
 export const getContexts = (
   config: TrackingProps,
-): SelfDescribingJson<Record<string, unknown>>[] => {
-  const contexts =
-    config &&
-    Object.entries(config)
-      .filter(([key]) => key.includes("Context") && key !== "includeGAContext")
-      .map(([_key, value]) => {
-        if (typeof value === "object") {
-          return snakeCaseKeys(({ ...value }));
-        }
-        return snakeCaseKeys({ data: { service_channel_identifier: value } });
-      });
+): Record<string, SerialisedEvent> => {
+  // Create an object that only contains Context keys
+  // and snake_case the keys
+  const contextEntries = Object.entries(config || {})
+    .filter(([key]) => key.includes("Context") && key !== "includeGAContext")
+    .reduce((acc, [key, value]) => {
+      if (typeof value === "object") {
+        return { ...acc, [key]: snakeCaseKeys({ ...value }) };
+      }
+      return {
+        ...acc,
+        [key]: snakeCaseKeys({ data: { service_channel_identifier: value } }),
+      };
+    }, {});
 
-  return contexts as unknown as SelfDescribingJson<Record<string, unknown>>[];
+  return contextEntries as Record<string, SerialisedEvent>;
 };
+
+export const updateIdentityContext = (
+  contexts: Record<string, SerialisedEvent>,
+  uid: unknown,
+): Record<string, SerialisedEvent> => {
+  const index = Object.keys(contexts).findIndex(ctx =>
+    contexts[ctx].schema?.includes("identity_context"),
+  );
+  if (index > -1) {
+    const key = Object.keys(contexts)[index];
+    return {
+      ...contexts,
+      [key]: {
+        ...contexts[key],
+        data: {
+          ...contexts[key].data,
+          domain_userid: uid,
+        },
+      },
+    };
+  }
+  return contexts;
+};
+
+export const makeContexts = (
+  keys: string[],
+  config: Record<string, SerialisedEvent>,
+): SerialisedEvent[] => (keys || []).map(key => config[key]);

package/src/snowplow/event-definitions/qcp.ts

@@ -1,27 +1,6 @@
 import { snakeCase } from "../../utils";
 import { EventDefinition, LinkType, ParamsType } from "../types";
 
-/**
- * Event definitions for Snowplow
- * @type {EventDefinition[]}
- * @property {string} name - The name of the event, to use when triggering
- * @property {string} type - The type of the event (structured | unstructured)
- * @property {makePayload} makePayload
- *   - Function that creates the payload for the event;
- *   - Allows optional params object to be passed in
- *
- * @example
- * Parent
- * import { getSnowplowConfig, SnowplowProvider } from "@simplybusiness/services";
- * const snowplowProps = getSnowplowConfig(pageData);
- * <SnowplowProvider scripts={snowplowProps!}>{children}</SnowplowProvider>
- *
- * Child
- * import { useSnowplowContext } from "@simplybusiness/services";
- * const { snowplow } = useSnowplowContext();
- * const handlerFunction = () => snowplow?.trigger("eventNameHere");
- */
-
 // QCP page events
 export const qcpEventDefinitions: EventDefinition[] = [
   {
@@ -143,6 +122,7 @@ export const qcpEventDefinitions: EventDefinition[] = [
         },
       };
     },
+    contexts: ["distributionChannelContext"],
   },
   {
     name: "ratingsModalOpened",
@@ -250,6 +230,7 @@ export const qcpEventDefinitions: EventDefinition[] = [
         },
       };
     },
+    contexts: ["serviceChannelContext"],
   },
   {
     name: "helpChatLinkClicked",

package/src/snowplow/event-definitions/questionnaire.ts

@@ -54,6 +54,7 @@ export const questionnaireEventDefinitions: EventDefinition[] = [
         },
       };
     },
+    contexts: ["distributionChannelContext"],
   },
   {
     name: "helpTextOpened",

package/src/snowplow/index.test.ts

@@ -2,13 +2,14 @@ import * as SnowplowLib from "@snowplow/browser-tracker";
 import { waitFor } from "@testing-library/dom";
 import eventDefinitions from "../mocks/eventDefinitions";
 import { pageData } from "../mocks/scripts-mock";
-import { getContexts } from "./contexts";
+import { getContexts, makeContexts } from "./contexts";
 import { getSnowplowConfig } from "./getSnowplowConfig";
 import { Snowplow } from "./Snowplow";
 import { EventDefinition, PageDataProps, TrackingProps } from "./types";
 
 const snowplowProps = getSnowplowConfig(pageData as PageDataProps);
 const contexts = getContexts(snowplowProps as TrackingProps);
+const fqaContext = makeContexts(["distributionChannelContext"], contexts);
 
 let testSnowplow = new Snowplow(snowplowProps as TrackingProps);
 testSnowplow.setContexts(contexts);
@@ -39,13 +40,14 @@ describe("Snowplow Analytics Class", () => {
 
     it("sets contexts on instantiation", () => {
       expect(testSnowplow.contexts).toEqual(contexts);
+      expect(testSnowplow.pvContext).toEqual(Object.values(contexts));
     });
 
     it("tracks page view event and adds contexts", async () => {
       const trackViewSpy = jest.spyOn(testSnowplow, "trackView");
       const innerSpy = jest
         .spyOn(SnowplowLib, "trackPageView")
-        .mockImplementation(() => { });
+        .mockImplementation(() => {});
 
       await testSnowplow.trackView();
 
@@ -53,7 +55,7 @@ describe("Snowplow Analytics Class", () => {
         expect(trackViewSpy).toHaveBeenCalledTimes(1);
         expect(trackViewSpy).toHaveBeenCalledWith();
         expect(innerSpy).toHaveBeenCalledTimes(1);
-        expect(innerSpy).toHaveBeenCalledWith({ context: contexts });
+        expect(innerSpy).toHaveBeenCalledWith({});
       });
     });
 
@@ -61,7 +63,7 @@ describe("Snowplow Analytics Class", () => {
       const trackStructEventSpy = jest.spyOn(testSnowplow, "trackEvent");
       const innerSpy = jest
         .spyOn(SnowplowLib, "trackStructEvent")
-        .mockImplementation(() => { });
+        .mockImplementation(() => {});
 
       const payload = {
         category: "mobile-link",
@@ -74,9 +76,10 @@ describe("Snowplow Analytics Class", () => {
       expect(trackStructEventSpy).toHaveBeenCalledTimes(1);
       expect(trackStructEventSpy).toHaveBeenCalledWith(payload);
       expect(innerSpy).toHaveBeenCalledTimes(1);
-      expect(innerSpy).toHaveBeenCalledWith({ ...payload, context: contexts }, [
-        "sb-ava-br",
-      ]);
+      expect(innerSpy).toHaveBeenCalledWith(
+        { ...payload, context: testSnowplow.structContext },
+        ["sb-ava-br"],
+      );
     });
 
     it("tracks self-describing event and adds contexts", async () => {
@@ -86,7 +89,7 @@ describe("Snowplow Analytics Class", () => {
       );
       const innerSpy = jest
         .spyOn(SnowplowLib, "trackSelfDescribingEvent")
-        .mockImplementation(() => { });
+        .mockImplementation(() => {});
 
       const testEvent = {
         schema:
@@ -106,7 +109,6 @@ describe("Snowplow Analytics Class", () => {
       expect(innerSpy).toHaveBeenCalledWith(
         {
           event: testEvent,
-          context: contexts,
         },
         ["sb-ava"],
       );
@@ -129,7 +131,7 @@ describe("Snowplow Analytics Class", () => {
         const trackStructEventSpy = jest.spyOn(testSnowplow, "trackEvent");
         const innerSpy = jest
           .spyOn(SnowplowLib, "trackStructEvent")
-          .mockImplementation(() => { });
+          .mockImplementation(() => {});
 
         await testSnowplow.trigger("navButtonClicked", { label: "test-label" });
 
@@ -144,7 +146,7 @@ describe("Snowplow Analytics Class", () => {
         expect(trackStructEventSpy).toHaveBeenCalledWith(expectedPayload);
         expect(innerSpy).toHaveBeenCalledTimes(1);
         expect(innerSpy).toHaveBeenCalledWith(
-          { ...expectedPayload, context: contexts },
+          { ...expectedPayload, context: testSnowplow.structContext },
           ["sb-ava-br"],
         );
       });
@@ -158,7 +160,7 @@ describe("Snowplow Analytics Class", () => {
         );
         const innerSpy = jest
           .spyOn(SnowplowLib, "trackSelfDescribingEvent")
-          .mockImplementation(() => { });
+          .mockImplementation(() => {});
 
         await testSnowplow.trigger("questionAnswered", {
           question: "test-question",
@@ -182,12 +184,14 @@ describe("Snowplow Analytics Class", () => {
         };
 
         expect(trackUnstructEventSpy).toHaveBeenCalledTimes(1);
-        expect(trackUnstructEventSpy).toHaveBeenCalledWith(expectedPayload);
+        expect(trackUnstructEventSpy).toHaveBeenCalledWith(expectedPayload, [
+          "distributionChannelContext",
+        ]);
         expect(innerSpy).toHaveBeenCalledTimes(1);
         expect(innerSpy).toHaveBeenCalledWith(
           {
             event: expectedPayload,
-            context: contexts,
+            context: fqaContext,
           },
           ["sb-ava"],
         );
@@ -202,7 +206,7 @@ describe("Snowplow Analytics Class", () => {
         );
         const innerSpy = jest
           .spyOn(SnowplowLib, "trackSelfDescribingEvent")
-          .mockImplementation(() => { });
+          .mockImplementation(() => {});
 
         await testSnowplow.trigger("questionAnswered", {
           question: "sof_bankrupt_yes",
@@ -226,12 +230,14 @@ describe("Snowplow Analytics Class", () => {
         };
 
         expect(trackUnstructEventSpy).toHaveBeenCalledTimes(1);
-        expect(trackUnstructEventSpy).toHaveBeenCalledWith(expectedPayload);
+        expect(trackUnstructEventSpy).toHaveBeenCalledWith(expectedPayload, [
+          "distributionChannelContext",
+        ]);
         expect(innerSpy).toHaveBeenCalledTimes(1);
         expect(innerSpy).toHaveBeenCalledWith(
           {
             event: expectedPayload,
-            context: contexts,
+            context: fqaContext,
           },
           ["sb-ava"],
         );
@@ -246,7 +252,7 @@ describe("Snowplow Analytics Class", () => {
         );
         const innerSpy = jest
           .spyOn(SnowplowLib, "trackSelfDescribingEvent")
-          .mockImplementation(() => { });
+          .mockImplementation(() => {});
 
         await testSnowplow.trigger("questionAnswered", {
           question: "have_secondary_trade_yes",
@@ -270,12 +276,14 @@ describe("Snowplow Analytics Class", () => {
         };
 
         expect(trackUnstructEventSpy).toHaveBeenCalledTimes(1);
-        expect(trackUnstructEventSpy).toHaveBeenCalledWith(expectedPayload);
+        expect(trackUnstructEventSpy).toHaveBeenCalledWith(expectedPayload, [
+          "distributionChannelContext",
+        ]);
         expect(innerSpy).toHaveBeenCalledTimes(1);
         expect(innerSpy).toHaveBeenCalledWith(
           {
             event: expectedPayload,
-            context: contexts,
+            context: fqaContext,
           },
           ["sb-ava"],
         );
@@ -290,7 +298,7 @@ describe("Snowplow Analytics Class", () => {
         );
         const innerSpy = jest
           .spyOn(SnowplowLib, "trackSelfDescribingEvent")
-          .mockImplementation(() => { });
+          .mockImplementation(() => {});
 
         await testSnowplow.trigger("questionAnswered", {
           question: "address_lookup",
@@ -314,12 +322,14 @@ describe("Snowplow Analytics Class", () => {
         };
 
         expect(trackUnstructEventSpy).toHaveBeenCalledTimes(1);
-        expect(trackUnstructEventSpy).toHaveBeenCalledWith(expectedPayload);
+        expect(trackUnstructEventSpy).toHaveBeenCalledWith(expectedPayload, [
+          "distributionChannelContext",
+        ]);
         expect(innerSpy).toHaveBeenCalledTimes(1);
         expect(innerSpy).toHaveBeenCalledWith(
           {
             event: expectedPayload,
-            context: contexts,
+            context: fqaContext,
           },
           ["sb-ava"],
         );
@@ -347,7 +357,7 @@ describe("Snowplow Analytics Class", () => {
           );
           const innerSpy = jest
             .spyOn(SnowplowLib, "trackSelfDescribingEvent")
-            .mockImplementation(() => { });
+            .mockImplementation(() => {});
 
           await testSnowplow.trigger("primaryDetailSelected", {
             answer,
@@ -370,7 +380,6 @@ describe("Snowplow Analytics Class", () => {
           expect(innerSpy).toHaveBeenCalledWith(
             {
               event: expectedPayload,
-              context: contexts,
             },
             ["sb-ava"],
           );
@@ -386,7 +395,7 @@ describe("Snowplow Analytics Class", () => {
         );
         const innerSpy = jest
           .spyOn(SnowplowLib, "trackSelfDescribingEvent")
-          .mockImplementation(() => { });
+          .mockImplementation(() => {});
 
         await testSnowplow.trigger("helpTextOpened", {
           primaryText: "Sample text",
@@ -412,7 +421,6 @@ describe("Snowplow Analytics Class", () => {
         expect(innerSpy).toHaveBeenCalledWith(
           {
             event: expectedPayload,
-            context: contexts,
           },
           ["sb-ava"],
         );
@@ -427,7 +435,7 @@ describe("Snowplow Analytics Class", () => {
         );
         const innerSpy = jest
           .spyOn(SnowplowLib, "trackSelfDescribingEvent")
-          .mockImplementation(() => { });
+          .mockImplementation(() => {});
 
         await testSnowplow.trigger("questionAnswered", {
           question: "test-question",
@@ -451,12 +459,14 @@ describe("Snowplow Analytics Class", () => {
         };
 
         expect(trackUnstructEventSpy).toHaveBeenCalledTimes(1);
-        expect(trackUnstructEventSpy).toHaveBeenCalledWith(expectedPayload);
+        expect(trackUnstructEventSpy).toHaveBeenCalledWith(expectedPayload, [
+          "distributionChannelContext",
+        ]);
         expect(innerSpy).toHaveBeenCalledTimes(1);
         expect(innerSpy).toHaveBeenCalledWith(
           {
             event: expectedPayload,
-            context: contexts,
+            context: fqaContext,
           },
           ["sb-ava"],
         );

package/src/snowplow/types.ts

@@ -50,12 +50,15 @@ export type LinkType = Record<string, string> & {
   elementContent: string;
 };
 
+export type SerialisedEvent = SelfDescribingJson<Record<string, unknown>>;
+
 export type EventDefinition = {
   name: string;
   type: "structured" | "unstructured";
   makePayload: (
     params?: Record<string, unknown>,
-  ) => StructuredEvent | SelfDescribingJson<Record<string, unknown>>;
+  ) => StructuredEvent | SerialisedEvent;
+  contexts?: string[];
 };
 
 export interface PageDataProps