Merge pull request #448 from elbwalker/447-data-policy

447 data policy

Author: alexanderkirtzel

.changeset/soft-moles-rush.md

@@ -0,0 +1,9 @@
+---
+'@elbwalker/destination-web-piwikpro': minor
+'@elbwalker/walker.js': minor
+'@elbwalker/client-node': minor
+'@elbwalker/types': minor
+'@elbwalker/utils': minor
+---
+
+Data Policy [#447]https://(github.com/elbwalker/walkerOS/issues/447)

packages/clients/node/src/__tests__/destination.test.ts

@@ -345,4 +345,46 @@ describe('Destination', () => {
       }),
     );
   });
+
+  test('policy', async () => {
+    const event = createEvent();
+
+    const policy = {
+      event: {
+        value: 'new name',
+      },
+      'data.string': { value: 'bar' },
+      'nested.0.type': { value: 'kid' },
+      'data.number': {
+        consent: { marketing: true },
+      },
+      'data.new': { value: 'value' },
+      // timing: { value: 'now' }, // @TODO shouldn't be possible
+    };
+
+    const destination: NodeDestination.Destination = {
+      config: { policy },
+      push: async (e) => {
+        mockPush(e);
+      },
+    };
+
+    const { elb } = getClient({
+      destinations: { destination },
+    });
+
+    await elb(event);
+
+    expect(mockPush).toHaveBeenCalledWith({
+      ...event,
+      event: 'new name',
+      data: expect.objectContaining({
+        string: 'bar',
+        number: undefined, // Redacted due to missing consent
+        new: 'value',
+      }),
+      nested: [expect.objectContaining({ type: 'kid' })],
+      // timing: 0, // @TODO should be set to default type
+    });
+  });
 });

packages/clients/node/src/lib/push.ts

@@ -3,7 +3,9 @@ import type { NodeClient, NodeDestination } from '../types';
 import {
   assign,
   getGrantedConsent,
+  getMappingValue,
   isSameType,
+  setByPath,
   tryCatchAsync,
 } from '@elbwalker/utils';
 import { isCommand } from './helper';
@@ -93,7 +95,16 @@ export async function pushToDestinations(
       destination.queue = []; // Reset original queue while processing
 
       // Add event to queue stack
-      if (event) queue.push(event);
+      if (event) {
+        // Policy check
+        Object.entries(destination.config.policy || []).forEach(
+          ([key, mapping]) => {
+            setByPath(event, key, getMappingValue(event, mapping, instance));
+          },
+        );
+
+        queue.push(event);
+      }
 
       // Nothing to do here if the queue is empty
       if (!queue.length) return { id, destination, skipped: true };

packages/clients/walkerjs/src/__tests__/destination.test.ts

@@ -1,6 +1,7 @@
 import { mockDataLayer } from '@elbwalker/jest/web.setup';
 import type { WebClient, WebDestination } from '..';
 import { elb, Walkerjs } from '..';
+import { createEvent } from '@elbwalker/utils';
 
 describe('Destination', () => {
   let walkerjs: WebClient.Instance;
@@ -844,4 +845,49 @@ describe('Destination', () => {
       }),
     );
   });
+
+  test('policy', () => {
+    const event = createEvent();
+
+    const policy = {
+      event: {
+        value: 'new name',
+      },
+      'data.string': { value: 'bar' },
+      'nested.0.type': { value: 'kid' },
+      'data.number': {
+        consent: { marketing: true },
+      },
+      'data.new': { value: 'value' },
+      // timing: { value: 'now' }, // @TODO shouldn't be possible
+    };
+
+    const destination: WebDestination.Destination = {
+      config: { policy },
+      push: (e) => {
+        mockPush(e);
+      },
+    };
+
+    walkerjs = Walkerjs({
+      run: true,
+      pageview: false,
+      session: false,
+      destinations: { destination },
+    });
+
+    elb(event);
+
+    expect(mockPush).toHaveBeenCalledWith({
+      ...event,
+      event: 'new name',
+      data: expect.objectContaining({
+        string: 'bar',
+        number: undefined, // Redacted due to missing consent
+        new: 'value',
+      }),
+      nested: [expect.objectContaining({ type: 'kid' })],
+      // timing: 0, // @TODO should be set to default type
+    });
+  });
 });

packages/clients/walkerjs/src/lib/push.ts

@@ -6,7 +6,9 @@ import {
   Const,
   assign,
   getGrantedConsent,
+  getMappingValue,
   isSameType,
+  setByPath,
   tryCatch,
   useHooks,
 } from '@elbwalker/utils';
@@ -114,8 +116,17 @@ export function pushToDestinations(
   Object.values(destinations).forEach((destination) => {
     destination.queue = destination.queue || [];
 
-    // Add event to queue stack
-    if (event) destination.queue.push(event);
+    if (event) {
+      // Policy check
+      Object.entries(destination.config.policy || []).forEach(
+        ([key, mapping]) => {
+          setByPath(event, key, getMappingValue(event, mapping, instance));
+        },
+      );
+
+      // Add event to queue stack
+      destination.queue.push(event);
+    }
 
     const allowedEvents: WalkerOS.Events = [];
     destination.queue = destination.queue.filter((queuedEvent) => {

packages/destinations/web/piwikpro/src/index.test.ts

@@ -7,7 +7,6 @@ describe('Destination PiwikPro', () => {
 
   const mockFn = jest.fn(); //.mockImplementation(console.log);
 
-  const event = 'entity action';
   const appId = 'XXX-XXX-XXX-XXX-XXX';
   const url = 'https://your_account_name.piwik.pro/';
 
@@ -32,9 +31,9 @@ describe('Destination PiwikPro', () => {
     expect(true).toBeTruthy();
   });
 
-  test.skip('push', () => {
-    elb('walker destination', destination);
-    elb(event);
-    // expect(mockFn).toHaveBeenNthCalledWith(1, event);
-  });
+  // test('push', () => {
+  //   elb('walker destination', destination);
+  //   elb(event);
+  //   // expect(mockFn).toHaveBeenNthCalledWith(1, event);
+  // });
 });

packages/destinations/web/piwikpro/src/index.ts

@@ -1,5 +1,5 @@
 import type { Custom, CustomEvent, Destination } from './types';
-import { getByStringDot } from '@elbwalker/utils';
+import { getMappingValue } from '@elbwalker/utils';
 
 // @TODOs
 // - static values besides dynamic data values
@@ -51,7 +51,10 @@ export const destinationPiwikPro: Destination = {
       event.action === 'view'
     ) {
       // Pageview tracking will move to run part in next version
-      window._paq!.push(['trackPageView', getByStringDot(event, 'data.title')]);
+      window._paq!.push([
+        'trackPageView',
+        getMappingValue(event, 'data.title'),
+      ]);
 
       return;
     }
@@ -61,9 +64,9 @@ export const destinationPiwikPro: Destination = {
     let name: unknown, value: unknown; // @TODO fix types
 
     if (customMapping) {
-      if (customMapping.name) name = getByStringDot(event, customMapping.name);
+      if (customMapping.name) name = getMappingValue(event, customMapping.name);
       if (customMapping.value)
-        value = getByStringDot(event, customMapping.value);
+        value = getMappingValue(event, customMapping.value);
     }
 
     window._paq!.push([
@@ -77,7 +80,7 @@ export const destinationPiwikPro: Destination = {
 
     if (customMapping.goalId) {
       const goalValue = customMapping.goalValue
-        ? getByStringDot(event, customMapping.goalValue)
+        ? getMappingValue(event, customMapping.goalValue)
         : undefined;
 
       window._paq!.push([

packages/types/src/destination.ts

@@ -14,12 +14,17 @@ export interface Config<Custom = unknown, CustomEvent = unknown> {
   init?: boolean; // If the destination has been initialized by calling the init method
   loadScript?: boolean; // If an additional script to work should be loaded
   mapping?: Mapping.Config<CustomEvent>; // A map to handle events individually
+  policy?: Policy; // Rules for processing events
   queue?: boolean; // Disable processing of previously pushed events
   verbose?: boolean; // Enable verbose logging
   onError?: Handler.Error; // Custom error handler
   onLog?: Handler.Log; // Custom log handler
 }
 
+export interface Policy {
+  [key: string]: Mapping.Value;
+}
+
 export type PushEvent<CustomEvent = unknown> = {
   event: WalkerOS.Event;
   mapping?: Mapping.Event<CustomEvent>;

packages/utils/src/__tests__/byPath.test.ts

@@ -0,0 +1,40 @@
+import { createEvent, getByPath, setByPath } from '../core';
+
+describe('byPath', () => {
+  test('getByPath', () => {
+    const obj = {
+      foo: 'bar',
+      a: { b: 'c' },
+      i: [0, 1, { id: 'dynamic' }],
+    };
+    expect(getByPath(obj, 'foo')).toBe('bar');
+    expect(getByPath(obj, 'unknown')).toBe(undefined);
+    expect(getByPath(obj, 'a.b')).toBe('c');
+    expect(getByPath(obj, 'i.2.id')).toBe('dynamic');
+    expect(getByPath(obj, 'i.*.id', 'unknown', 2)).toStrictEqual([
+      'unknown',
+      'unknown',
+      'dynamic',
+    ]);
+    expect(getByPath(undefined, 'na')).toBe(undefined);
+  });
+
+  test('setByPath', () => {
+    const event = createEvent();
+
+    // expect(setByPath(event, 'foo', 'bar')).not.toHaveProperty('foo'); // @TODO
+    expect(setByPath(event, 'timing', 2)).toHaveProperty('timing', 2);
+    expect(setByPath(event, 'data.string', 'updated')).toHaveProperty(
+      'data.string',
+      'updated',
+    );
+    expect(setByPath(event, 'data.array.1', 'bar')).toHaveProperty(
+      'data.array.1',
+      'bar',
+    );
+    expect(setByPath(event, 'nested', [])).toHaveProperty('nested', []);
+    expect(setByPath(event, 'data', { a: 1 })).toStrictEqual(
+      expect.objectContaining({ data: { a: 1 } }),
+    );
+  });
+});