@simplybusiness/services 0.20.1 → 0.21.1

package/dist/esm/snowplow/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/snowplow/types.ts"],"sourcesContent":["import {\n  EventMethod,\n  SelfDescribingJson,\n  StructuredEvent,\n} from \"@snowplow/browser-tracker\";\n\ntype BaseConfig = {\n  appId: string;\n  avalancheCollector: string;\n  eventMethod: EventMethod;\n  trackPageView: boolean;\n  includeGAContext: boolean;\n  uid?: string;\n  postPath?: string;\n};\n\nexport type EnvConfig = BaseConfig & {\n  cookieDomain: Record<string, string>;\n};\n\nexport type TrackingProps = BaseConfig & {\n  eventMethod: EventMethod;\n  cookieDomain?: string;\n  pageViewContext?: ChannelContext;\n};\n\nexport type ChannelContext = {\n  schema: string;\n  data: Record<string, string | number>;\n};\n\nexport type ChannelContexts = Record<string, ChannelContext>;\n\nexport type ArrayOneOrMore<T> = [T, ...T[]];\n\nexport type ParamsType = Record<string, string> & {\n  context: ServerContext;\n};\n\ntype ServerContext = {\n  site: string;\n  vertical: string;\n  primary_detail: string;\n  journey_name: string;\n  journey_id: string;\n};\n\nexport type LinkType = Record<string, string> & {\n  targetUrl: string;\n  elementContent: string;\n};\n\nexport type EventDefinition = {\n  name: string;\n  type: \"structured\" | \"unstructured\";\n  makePayload: (\n    params?: Record<string, unknown>,\n  ) => StructuredEvent | SelfDescribingJson<Record<string, unknown>>;\n};\n\nexport interface PageDataProps\n  extends Partial<\n    Record<\n      \"scripts\",\n      Array<{\n        metadata: { name: string };\n        props?: Record<string, unknown>;\n      }>\n    >\n  > {}\n"],"names":[],"mappings":"AA4DA,WASM"}
+{"version":3,"sources":["../../../src/snowplow/types.ts"],"sourcesContent":["import {\n  EventMethod,\n  SelfDescribingJson,\n  StructuredEvent,\n} from \"@snowplow/browser-tracker\";\n\ntype BaseConfig = {\n  appId: string;\n  avalancheCollector: string;\n  eventMethod: EventMethod;\n  trackPageView: boolean;\n  includeGAContext: boolean;\n  uid?: string;\n  postPath?: string;\n};\n\nexport type EnvConfig = BaseConfig & {\n  cookieDomain: Record<string, string>;\n};\n\nexport type TrackingProps = BaseConfig & {\n  eventMethod: EventMethod;\n  cookieDomain?: string;\n  pageViewContext?: ChannelContext;\n};\n\nexport type ChannelContext = {\n  schema: string;\n  data: Record<string, string | number>;\n};\n\nexport type ChannelContexts = Record<string, ChannelContext>;\n\nexport type ArrayOneOrMore<T> = [T, ...T[]];\n\nexport type ParamsType = Record<string, string> & {\n  context: ServerContext;\n};\n\ntype ServerContext = {\n  site: string;\n  vertical: string;\n  primary_detail: string;\n  journey_name: string;\n  journey_id: string;\n};\n\nexport type LinkType = Record<string, string> & {\n  targetUrl: string;\n  elementContent: string;\n};\n\nexport type SerialisedEvent = SelfDescribingJson<Record<string, unknown>>;\n\nexport type EventDefinition = {\n  name: string;\n  type: \"structured\" | \"unstructured\";\n  makePayload: (\n    params?: Record<string, unknown>,\n  ) => StructuredEvent | SerialisedEvent;\n  contexts?: string[];\n};\n\nexport interface PageDataProps\n  extends Partial<\n    Record<\n      \"scripts\",\n      Array<{\n        metadata: { name: string };\n        props?: Record<string, unknown>;\n      }>\n    >\n  > {}\n"],"names":[],"mappings":"AA+DA,WASM"}

package/dist/types/mocks/eventDefinitions.d.ts

@@ -10,25 +10,7 @@ declare const _default: ({
         label: "next" | "back" | "redirect";
         property: string;
     };
-} | {
-    name: string;
-    type: string;
-    makePayload: (params: {
-        vertical?: string;
-        question: string;
-        answer?: string;
-    }) => {
-        schema: string;
-        data: {
-            site: string;
-            vertical: string;
-            page_index: number;
-            page_name: string;
-            section_name: string;
-            question: string;
-            answer: string | undefined;
-        };
-    };
+    contexts?: undefined;
 } | {
     name: string;
     type: string;
@@ -45,6 +27,7 @@ declare const _default: ({
             vertical: string;
         };
     };
+    contexts: string[];
 } | {
     name: string;
     type: string;
@@ -56,6 +39,7 @@ declare const _default: ({
             primary_detail: string;
         };
     };
+    contexts?: undefined;
 } | {
     name: string;
     type: string;
@@ -70,5 +54,6 @@ declare const _default: ({
             page_name: string;
         };
     };
+    contexts?: undefined;
 })[];
 export default _default;

package/dist/types/snowplow/Snowplow.d.ts

@@ -1,5 +1,5 @@
-import { SelfDescribingJson, StructuredEvent, PageViewEvent } from "@snowplow/browser-tracker";
-import { EventDefinition, TrackingProps } from "./types";
+import { PageViewEvent, StructuredEvent } from "@snowplow/browser-tracker";
+import { EventDefinition, SerialisedEvent, TrackingProps } from "./types";
 export type FrontOfficeStructuredEvent = StructuredEvent & {
     serviceChannelIdentifier: string;
 };
@@ -15,15 +15,17 @@ export declare class Snowplow {
     pvAvalancheTrackerName: string;
     uid: unknown;
     trackPageView: boolean;
-    contexts: SelfDescribingJson<Record<string, unknown>>[];
+    contexts: Record<string, SerialisedEvent>;
+    pvContext: SerialisedEvent[];
+    structContext: SerialisedEvent[];
     serverData: Record<string, unknown>;
     eventHandlers: Record<string, (params?: Record<string, unknown>) => void>;
     static instance: Snowplow | undefined;
     constructor(props?: TrackingProps);
-    setContexts(contexts: SelfDescribingJson<Record<string, unknown>>[]): this;
+    setContexts(contexts: Record<string, SerialisedEvent>): this;
     trackView(event?: PageViewEvent): Promise<this>;
     trackEvent(event: StructuredEvent): Promise<this>;
-    trackUnstructEvent(event: SelfDescribingJson<Record<string, unknown>>): Promise<this>;
+    trackUnstructEvent(event: SerialisedEvent, contexts?: string[]): Promise<this>;
     addEventHandlers(eventDefinitions: EventDefinition[]): this;
     private addEventHandler;
     private removeEventHandler;

package/dist/types/snowplow/contexts.d.ts

@@ -1,3 +1,4 @@
-import { SelfDescribingJson } from "@snowplow/browser-tracker";
-import { TrackingProps } from "./types";
-export declare const getContexts: (config: TrackingProps) => SelfDescribingJson<Record<string, unknown>>[];
+import { SerialisedEvent, TrackingProps } from "./types";
+export declare const getContexts: (config: TrackingProps) => Record<string, SerialisedEvent>;
+export declare const updateIdentityContext: (contexts: Record<string, SerialisedEvent>, uid: unknown) => Record<string, SerialisedEvent>;
+export declare const makeContexts: (keys: string[], config: Record<string, SerialisedEvent>) => SerialisedEvent[];

package/dist/types/snowplow/event-definitions/index.d.ts

@@ -1,6 +1,7 @@
 export declare const eventDefinitions: import("..").EventDefinition[];
 export declare const qcpPageEvents: import("..").EventDefinition[];
 export declare const referralPageEvents: import("..").EventDefinition[];
+export declare const personalisedCoverPageEvents: import("..").EventDefinition[];
 export declare const interventionPageEvents: import("..").EventDefinition[];
 export type { InterventionPayload } from "./intervention";
 export declare const questionnairePageEvents: import("..").EventDefinition[];

package/dist/types/snowplow/event-definitions/personalised_cover.d.ts

@@ -0,0 +1,22 @@
+import { EventDefinition } 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");
+ */
+export declare const personalisedCoverEventDefinitions: EventDefinition[];

package/dist/types/snowplow/event-definitions/qcp.d.ts

@@ -1,22 +1,2 @@
 import { EventDefinition } 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");
- */
 export declare const qcpEventDefinitions: EventDefinition[];

package/dist/types/snowplow/types.d.ts

@@ -36,10 +36,12 @@ export type LinkType = Record<string, string> & {
     targetUrl: 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>>;
+    makePayload: (params?: Record<string, unknown>) => StructuredEvent | SerialisedEvent;
+    contexts?: string[];
 };
 export interface PageDataProps extends Partial<Record<"scripts", Array<{
     metadata: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@simplybusiness/services",
   "license": "UNLICENSED",
-  "version": "0.20.1",
+  "version": "0.21.1",
   "description": "Internal library for services",
   "repository": {
     "type": "git",
@@ -42,40 +42,40 @@
     "react-dom": "^18.2.0 || ^19.0.0"
   },
   "devDependencies": {
-    "@swc/cli": "^0.5.2",
-    "@swc/core": "^1.10.1",
+    "@swc/cli": "^0.6.0",
+    "@swc/core": "^1.11.9",
     "@swc/jest": "^0.2.37",
     "@testing-library/dom": "^10.4.0",
     "@testing-library/jest-dom": "6.6.3",
-    "@testing-library/react": "^16.1.0",
+    "@testing-library/react": "^16.2.0",
     "@types/jest": "^29.5.14",
-    "@types/react": "^18.3.16",
+    "@types/react": "^18.3.18",
     "@types/react-dom": "^18.3.5",
-    "@typescript-eslint/eslint-plugin": "^8.18.0",
-    "@typescript-eslint/parser": "^8.18.0",
+    "@typescript-eslint/eslint-plugin": "^8.26.1",
+    "@typescript-eslint/parser": "^8.26.1",
     "eslint": "^8.57.1",
     "eslint-config-airbnb": "^19.0.4",
     "eslint-config-prettier": "^9.1.0",
-    "eslint-import-resolver-typescript": "^3.7.0",
+    "eslint-import-resolver-typescript": "^3.8.6",
     "eslint-plugin-import": "^2.31.0",
     "eslint-plugin-jsx-a11y": "^6.10.2",
     "eslint-plugin-no-only-tests": "^3.3.0",
-    "eslint-plugin-prettier": "^5.2.1",
-    "eslint-plugin-react": "^7.37.2",
-    "eslint-plugin-react-hooks": "^5.1.0",
+    "eslint-plugin-prettier": "^5.2.3",
+    "eslint-plugin-react": "^7.37.4",
+    "eslint-plugin-react-hooks": "^5.2.0",
     "identity-obj-proxy": "^3.0.0",
     "jest": "^29.7.0",
     "jest-environment-jsdom": "^29.7.0",
-    "prettier": "^3.4.2",
+    "prettier": "^3.5.3",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
-    "ts-jest": "^29.2.5",
+    "ts-jest": "^29.2.6",
     "tslib": "^2.8.1",
-    "typescript": "^5.7.2"
+    "typescript": "^5.8.2"
   },
   "dependencies": {
-    "@airbrake/browser": "^2.1.8",
-    "@simplybusiness/mobius": "^5.24.2",
+    "@airbrake/browser": "^2.1.9",
+    "@simplybusiness/mobius": "^5.24.3",
     "@snowplow/browser-tracker": "^3.24.6",
     "classnames": "^2.5.1"
   },

package/src/mocks/eventDefinitions.ts

@@ -15,30 +15,6 @@ export default [
       };
     },
   },
-  {
-    name: "questionAnswered",
-    type: "unstructured",
-    makePayload: (params: {
-      vertical?: string;
-      question: string;
-      answer?: string;
-    }) => {
-      const { vertical, question, answer } = params;
-      return {
-        schema:
-          "iglu:com.simplybusiness/form_question_answered/jsonschema/1-0-1",
-        data: {
-          site: "",
-          vertical: vertical || "business",
-          page_index: 1,
-          page_name: "Coverage diagnosis questionnaire",
-          section_name: "Coverage diagnosis questionnaire",
-          question,
-          answer,
-        },
-      };
-    },
-  },
   {
     name: "questionAnswered",
     type: "unstructured",
@@ -61,6 +37,7 @@ export default [
         },
       };
     },
+    contexts: ["distributionChannelContext"],
   },
   {
     name: "primaryDetailSelected",
@@ -68,7 +45,7 @@ export default [
     makePayload: (params: ParamsType) => {
       const { context, answer, vertical } = params as ParamsType;
       const { site } = context;
-      let verticalName = vertical ? vertical : context.vertical;
+      let verticalName = vertical || context.vertical;
 
       if (verticalName.toLowerCase().indexOf("landlord") > -1) {
         verticalName =

package/src/snowplow/Snowplow.ts

@@ -1,5 +1,5 @@
 import {
-  SelfDescribingJson,
+  PageViewEvent,
   StructuredEvent,
   TrackerConfiguration,
   newTracker,
@@ -8,9 +8,9 @@ import {
   trackPageView,
   trackSelfDescribingEvent,
   trackStructEvent,
-  PageViewEvent,
 } from "@snowplow/browser-tracker";
-import { EventDefinition, TrackingProps } from "./types";
+import { makeContexts, updateIdentityContext } from "./contexts";
+import { EventDefinition, SerialisedEvent, TrackingProps } from "./types";
 
 export type FrontOfficeStructuredEvent = StructuredEvent & {
   serviceChannelIdentifier: string;
@@ -33,7 +33,11 @@ export class Snowplow {
 
   trackPageView: boolean = false;
 
-  contexts: SelfDescribingJson<Record<string, unknown>>[] = [];
+  contexts: Record<string, SerialisedEvent> = {};
+
+  pvContext: SerialisedEvent[] = [];
+
+  structContext: SerialisedEvent[] = [];
 
   serverData: Record<string, unknown> = {};
 
@@ -52,8 +56,6 @@ export class Snowplow {
       eventMethod,
       uid,
       postPath,
-      // includeGAContext,
-      // trackActivity,
       trackPageView: tpv,
     } = props;
     this.uid = uid;
@@ -92,22 +94,20 @@ export class Snowplow {
     Snowplow.instance = this;
   }
 
-  setContexts(contexts: SelfDescribingJson<Record<string, unknown>>[]) {
-    this.contexts = contexts;
-    // Update identity context
-    const index = this.contexts?.findIndex(ctx =>
-      ctx.schema?.includes("identity_context"),
+  setContexts(contexts: Record<string, SerialisedEvent>) {
+    this.contexts = updateIdentityContext(contexts, this.uid);
+    this.pvContext = Object.values(this.contexts);
+    this.structContext = makeContexts(
+      ["distributionChannelContext", "serviceChannelContext"],
+      this.contexts,
     );
-    if (index > -1) {
-      this.contexts[index].data.domain_userid = this.uid;
-    }
     return this;
   }
 
   // Send a page view event
   async trackView(event?: PageViewEvent) {
     if (this.trackPageView) {
-      await trackPageView({ ...event, context: this.contexts }, [
+      await trackPageView({ ...event, context: this.pvContext }, [
         this.avalancheTrackerName,
       ]);
     }
@@ -116,20 +116,28 @@ export class Snowplow {
 
   // Send a structured event with contexts
   async trackEvent(event: StructuredEvent) {
-    await trackStructEvent({ ...event, context: this.contexts }, [
+    await trackStructEvent({ ...event, context: this.structContext }, [
       this.bronzeAvalancheTrackerName,
     ]);
     return this;
   }
 
   // Send a custom event with defined schema and optional contexts
-  async trackUnstructEvent(event: SelfDescribingJson<Record<string, unknown>>) {
+  async trackUnstructEvent(event: SerialisedEvent, contexts?: string[]) {
     if (!event) {
       return this;
     }
-    await trackSelfDescribingEvent({ event, context: this.contexts }, [
-      this.avalancheTrackerName,
-    ]);
+
+    if (contexts && Array.isArray(contexts) && contexts.length > 0) {
+      // Add context to the event
+      const context = makeContexts(contexts!, this.contexts);
+
+      await trackSelfDescribingEvent({ event, context }, [
+        this.avalancheTrackerName,
+      ]);
+    } else {
+      await trackSelfDescribingEvent({ event }, [this.avalancheTrackerName]);
+    }
     return this;
   }
 
@@ -137,7 +145,7 @@ export class Snowplow {
     // Add server context to makePayload functions
     const context = this.serverData;
 
-    eventDefinitions.forEach(({ name, type, makePayload }) => {
+    eventDefinitions.forEach(({ name, type, makePayload, contexts }) => {
       // Convert type into relevant function
       if (type === "structured") {
         this.addEventHandler(name, (params?: Record<string, unknown>) => {
@@ -150,12 +158,16 @@ export class Snowplow {
         });
       } else {
         this.addEventHandler(name, (params?: Record<string, unknown>) => {
-          this.trackUnstructEvent(
-            makePayload({
-              ...params,
-              context,
-            }) as SelfDescribingJson<Record<string, unknown>>,
-          );
+          const payload = makePayload({
+            ...params,
+            context,
+          }) as SerialisedEvent;
+
+          if (contexts && Array.isArray(contexts) && contexts.length > 0) {
+            this.trackUnstructEvent(payload, contexts);
+          } else {
+            this.trackUnstructEvent(payload);
+          }
         });
       }
     });
@@ -176,8 +188,13 @@ export class Snowplow {
   }
 
   trigger(name: string, params?: Record<string, unknown>) {
-    if (this.eventHandlers[name]) {
-      this.eventHandlers[name](params);
+    const handler = this.eventHandlers[name];
+
+    if (
+      Object.prototype.hasOwnProperty.call(this.eventHandlers, name) &&
+      typeof handler === "function"
+    ) {
+      handler(params);
     }
     return this;
   }

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]);