addDestination util

Author: alexanderkirtzel

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

@@ -314,7 +314,8 @@ describe('Destination', () => {
     elb('foo bar');
 
     const eventMapping = { data: { value: 'bar' } };
-    await elb(
+
+    elb(
       'walker destination',
       { push: mockPush },
       {
@@ -323,6 +324,8 @@ describe('Destination', () => {
       },
     );
 
+    await jest.runAllTimersAsync();
+
     // Event data
     expect(mockPush).toHaveBeenCalledWith(
       expect.objectContaining({ event: 'foo bar' }),
@@ -347,7 +350,7 @@ describe('Destination', () => {
     elb('foo bar');
 
     const eventMapping = { data: { map: { foo: { value: 'bar' } } } };
-    await elb(
+    elb(
       'walker destination',
       { push: mockPush },
       {
@@ -356,6 +359,7 @@ describe('Destination', () => {
       },
     );
 
+    await jest.runAllTimersAsync();
     expect(mockPush).toHaveBeenCalledWith(
       expect.any(Object),
       expect.any(Object),
@@ -838,6 +842,7 @@ describe('Destination', () => {
 
     await elb('entity action');
     expect(mockDataLayer).toHaveBeenCalledTimes(0);
+
     await elb('walker consent', { functional: true });
     expect(mockDataLayer).toHaveBeenCalledTimes(1);
 
@@ -945,7 +950,6 @@ describe('Destination', () => {
     });
 
     await elb(event);
-
     expect(mockPush).toHaveBeenCalledWith({
       ...event,
       event: 'new name',

packages/sources/walkerjs/src/__tests__/trigger.test.ts

@@ -55,7 +55,8 @@ describe('Trigger', () => {
     const { elb } = createSourceWalkerjs({ default: true, session: false });
 
     // Both e load events should be triggered
-    await elb('walker init');
+    elb('walker init');
+    await jest.runAllTimersAsync();
     expect(mockDataLayer).toHaveBeenCalledWith(
       expect.objectContaining({
         event: 'e all',
@@ -72,6 +73,7 @@ describe('Trigger', () => {
 
     // Only the e init event should be triggered
     await elb('walker init', elem);
+    await jest.runAllTimersAsync();
     expect(mockDataLayer).not.toHaveBeenCalledWith(
       expect.objectContaining({ event: 'e all' }),
     );

packages/sources/walkerjs/src/index.ts

@@ -1,7 +1,6 @@
 import type { Elb, SourceWalkerjs } from './types';
-import { onApply } from '@elbwalker/utils';
+import { addDestination, onApply } from '@elbwalker/utils';
 import { sessionStart } from '@elbwalker/utils/web';
-import { addDestination } from './lib/destination';
 import { createPush, elbLayerInit } from './lib/push';
 import { run } from './lib/run';
 import { createSessionStart } from './lib/session';

packages/sources/walkerjs/src/lib/destination.ts

@@ -1,34 +1,4 @@
-import type { SourceWalkerjs, DestinationWeb } from '../types';
-import { getId, pushToDestinations } from '@elbwalker/utils';
-
-export async function addDestination(
-  instance: SourceWalkerjs.Instance,
-  data: DestinationWeb.DestinationInit,
-  options?: DestinationWeb.Config,
-) {
-  // Prefer explicit given config over default config
-  const config = options || data.config || { init: false };
-
-  const destination: DestinationWeb.Destination = {
-    ...data,
-    config,
-  };
-
-  let id = config.id; // Use given id
-  if (!id) {
-    // Generate a new id if none was given
-    do {
-      id = getId(4);
-    } while (instance.destinations[id]);
-  }
-
-  // Add the destination
-  instance.destinations[id] = destination;
-
-  // Process previous events if not disabled
-  if (config.queue !== false) destination.queue = [...instance.queue];
-  return await pushToDestinations(instance, { destination });
-}
+import type { DestinationWeb } from '../types';
 
 export function dataLayerDestination() {
   window.dataLayer = window.dataLayer || [];

packages/sources/walkerjs/src/lib/handle.ts

@@ -2,6 +2,7 @@ import type { Hooks, On, WalkerOS } from '@elbwalker/types';
 import type { SourceWalkerjs, DestinationWeb, Elb } from '../types';
 import {
   Const,
+  addDestination,
   assign,
   isArray,
   isElementOrDocument,
@@ -14,7 +15,6 @@ import {
 } from '@elbwalker/utils';
 import { initScopeTrigger, ready } from './trigger';
 import { getState } from './state';
-import { addDestination } from './destination';
 import { run } from './run';
 import { addHook } from './hooks';
 
@@ -40,18 +40,21 @@ export async function handleCommand(
         ).config;
       break;
     case Const.Commands.Consent:
-      if (isObject(data)) setConsent(instance, data as WalkerOS.Consent);
+      if (isObject(data)) {
+        const foo = await setConsent(instance, data as WalkerOS.Consent);
+      }
       break;
     case Const.Commands.Custom:
       if (isObject(data)) instance.custom = assign(instance.custom, data);
       break;
     case Const.Commands.Destination:
-      isObject(data) &&
-        addDestination(
+      if (isObject(data)) {
+        await addDestination(
           instance,
           data as DestinationWeb.Destination,
           options as DestinationWeb.Config,
         );
+      }
       break;
     case Const.Commands.Globals:
       if (isObject(data)) instance.globals = assign(instance.globals, data);
@@ -71,16 +74,23 @@ export async function handleCommand(
       on(instance, data as On.Types, options as On.Options);
       break;
     case Const.Commands.Run:
-      ready(instance, run, instance, data as Partial<SourceWalkerjs.State>);
+      await ready(
+        instance,
+        run,
+        instance,
+        data as Partial<SourceWalkerjs.State>,
+      );
       break;
     case Const.Commands.User:
       if (isObject(data)) assign(instance.user, data, { shallow: false });
       break;
     default:
       break;
   }
+
   result.status.ok = true;
 
+  // @TODO return result
   return result;
 }
 
@@ -105,11 +115,7 @@ export async function handleEvent(
     // Add event to internal queue
     instance.queue.push(event);
 
-    const foo = await pushToDestinations(
-      instance,
-      instance.destinations,
-      event,
-    );
+    await pushToDestinations(instance, instance.destinations, event);
 
     result.status.ok = true;
   })();

packages/sources/walkerjs/src/lib/trigger.ts

@@ -36,21 +36,21 @@ export const Trigger: { [key: string]: Walker.Trigger } = {
   Wait: 'wait',
 } as const;
 
-export function ready<T extends (...args: never[]) => R, R>(
+export async function ready<T extends (...args: never[]) => R, R>(
   instance: SourceWalkerjs.Instance,
   fn: T,
   ...args: Parameters<T>
-): void {
+): Promise<R | undefined> {
   const readyFn = () => {
-    fn(...args);
+    const result = fn(...args);
     onApply(instance, 'ready');
+    return result;
   };
 
   if (document.readyState !== 'loading') {
-    readyFn();
+    return readyFn();
   } else {
     document.addEventListener('DOMContentLoaded', readyFn);
-    return;
   }
 }
 

packages/sources/walkerjs/src/types/destination.ts

@@ -10,8 +10,7 @@ export interface Destination<Custom = unknown, CustomEvent = unknown>
   init?: WalkerOSDestination.InitFn<Custom, CustomEvent>;
 }
 
-export type DestinationInit = Partial<Omit<Destination, 'push'>> &
-  Pick<Destination, 'push'>;
+export type DestinationInit = WalkerOSDestination.DestinationInit;
 
 // @TODO move to WalkerOSDestination
 // check if used

packages/types/src/destination.ts

@@ -35,6 +35,9 @@ export interface Policy {
   [key: string]: Mapping.Value;
 }
 
+export type DestinationInit = Partial<Omit<Destination, 'push'>> &
+  Pick<Destination, 'push'>;
+
 export type InitFn<Custom, CustomEvent> = (
   config?: PartialConfig<Custom, CustomEvent>,
   instance?: WalkerOS.Instance,

packages/utils/src/core/destination.ts

@@ -4,18 +4,44 @@ import type {
   WalkerOS,
   Elb,
 } from '@elbwalker/types';
-import {
-  getMappingEvent,
-  getMappingValue,
-  isDefined,
-  assign,
-  isObject,
-  useHooks,
-  debounce,
-  setByPath,
-  getGrantedConsent,
-  tryCatchAsync,
-} from './index';
+import { getId } from './getId';
+import { setByPath } from './byPath';
+import { getMappingEvent, getMappingValue } from './mapping';
+import { getGrantedConsent } from './consent';
+import { tryCatchAsync } from './tryCatch';
+import { assign } from './assign';
+import { useHooks } from './useHooks';
+import { isDefined, isObject } from './is';
+import { debounce } from './invocations';
+
+export async function addDestination(
+  instance: WalkerOS.Instance,
+  data: WalkerOSDestination.DestinationInit,
+  options?: WalkerOSDestination.Config,
+) {
+  // Prefer explicit given config over default config
+  const config = options || data.config || { init: false };
+
+  const destination: WalkerOSDestination.Destination = {
+    ...data,
+    config,
+  };
+
+  let id = config.id; // Use given id
+  if (!id) {
+    // Generate a new id if none was given
+    do {
+      id = getId(4);
+    } while (instance.destinations[id]);
+  }
+
+  // Add the destination
+  instance.destinations[id] = destination;
+
+  // Process previous events if not disabled
+  if (config.queue !== false) destination.queue = [...instance.queue];
+  return pushToDestinations(instance, { destination });
+}
 
 export async function pushToDestinations(
   instance: WalkerOS.Instance,
@@ -41,14 +67,13 @@ export async function pushToDestinations(
       // Add event to queue stack
       if (event) {
         // Policy check
-        Object.entries(destination.config.policy || []).forEach(
-          ([key, mapping]) => {
-            setByPath(
-              event,
-              key,
-              getMappingValue(event, mapping, { instance }),
-            );
-          },
+        await Promise.all(
+          Object.entries(destination.config.policy || []).map(
+            async ([key, mapping]) => {
+              const value = await getMappingValue(event, mapping, { instance });
+              setByPath(event, key, value);
+            },
+          ),
         );
 
         queue.push(event);

packages/utils/src/core/mapping.ts

@@ -3,7 +3,7 @@ import { getGrantedConsent } from './consent';
 import { getByPath } from './byPath';
 import { isArray, isDefined, isString, isObject } from './is';
 import { castToProperty } from './property';
-import { tryCatch, tryCatchAsync } from './tryCatch';
+import { tryCatchAsync } from './tryCatch';
 
 export async function getMappingEvent(
   event: WalkerOS.PartialEvent,
@@ -71,7 +71,6 @@ export async function getMappingValue(
       ...options,
       consent: consentState,
     });
-
     if (isDefined(result)) return result;
   }
 }