utneque 1.0.0

package/packages/browser/src/plugins/schema-filter/__tests__/index.test.ts

@@ -0,0 +1,520 @@
+import { Plugin } from '../../../core/plugin'
+import { Analytics } from '../../../core/analytics'
+import { Context } from '../../../core/context'
+import { schemaFilter } from '..'
+import { LegacySettings } from '../../../browser'
+import { hightouchio, HightouchioSettings } from '../../hightouchio'
+
+const settings: LegacySettings = {
+  integrations: {
+    'Braze Web Mode (Actions)': {},
+    // note that Fullstory's name here doesn't contain 'Actions'
+    Fullstory: {},
+    'Hightouch.io': {},
+  },
+  remotePlugins: [
+    {
+      name: 'Braze Web Mode (Actions)',
+      creationName: 'Braze Web Mode (Actions)',
+      libraryName: 'brazeDestination',
+      url: 'https://cdn.hightouch-events.com/next-integrations/actions/braze/9850d2cc8308a89db62a.js',
+      settings: {
+        subscriptions: [
+          {
+            partnerAction: 'trackEvent',
+          },
+          {
+            partnerAction: 'updateUserProfile',
+          },
+          {
+            partnerAction: 'trackPurchase',
+          },
+        ],
+      },
+    },
+    {
+      // note that Fullstory name contains 'Actions'
+      name: 'Fullstory (Actions)',
+      creationName: 'Fullstory (Actions)',
+      libraryName: 'fullstoryDestination',
+      url: 'https://cdn.hightouch-events.com/next-integrations/actions/fullstory/35ea1d304f85f3306f48.js',
+      settings: {
+        subscriptions: [
+          {
+            partnerAction: 'trackEvent',
+          },
+          {
+            partnerAction: 'identifyUser',
+          },
+        ],
+      },
+    },
+  ],
+}
+
+const trackEvent: Plugin = {
+  name: 'Braze Web Mode (Actions) trackEvent',
+  type: 'destination',
+  version: '1.0',
+
+  load(_ctx: Context): Promise<void> {
+    return Promise.resolve()
+  },
+
+  isLoaded(): boolean {
+    return true
+  },
+
+  track: async (ctx) => ctx,
+  identify: async (ctx) => ctx,
+  page: async (ctx) => ctx,
+  group: async (ctx) => ctx,
+  alias: async (ctx) => ctx,
+}
+
+const trackPurchase: Plugin = {
+  ...trackEvent,
+  name: 'Braze Web Mode (Actions) trackPurchase',
+}
+
+const updateUserProfile: Plugin = {
+  ...trackEvent,
+  name: 'Braze Web Mode (Actions) updateUserProfile',
+}
+
+const amplitude: Plugin = {
+  ...trackEvent,
+  name: 'amplitude',
+}
+
+const fullstory: Plugin = {
+  ...trackEvent,
+  name: 'Fullstory (Actions) trackEvent',
+}
+
+describe('schema filter', () => {
+  let options: HightouchioSettings
+  let filterXt: Plugin
+  let hightouch: Plugin
+  let ajs: Analytics
+
+  beforeEach(async () => {
+    jest.resetAllMocks()
+    jest.restoreAllMocks()
+
+    options = { apiKey: 'foo' }
+    ajs = new Analytics({ writeKey: options.apiKey })
+    hightouch = await hightouchio(ajs, options, {})
+    filterXt = schemaFilter({}, settings)
+
+    jest.spyOn(hightouch, 'track')
+    jest.spyOn(trackEvent, 'track')
+    jest.spyOn(trackPurchase, 'track')
+    jest.spyOn(updateUserProfile, 'track')
+    jest.spyOn(amplitude, 'track')
+    jest.spyOn(fullstory, 'track')
+  })
+
+  describe('plugins and destinations', () => {
+    it('loads plugin', async () => {
+      await ajs.register(filterXt)
+      expect(filterXt.isLoaded()).toBe(true)
+    })
+
+    it('does not drop events when no plan is defined', async () => {
+      await ajs.register(
+        hightouch,
+        trackEvent,
+        trackPurchase,
+        updateUserProfile,
+        schemaFilter({}, settings)
+      )
+
+      await ajs.track('A Track Event')
+
+      expect(hightouch.track).toHaveBeenCalled()
+      expect(trackEvent.track).toHaveBeenCalled()
+      expect(trackPurchase.track).toHaveBeenCalled()
+      expect(updateUserProfile.track).toHaveBeenCalled()
+    })
+
+    it('drops an event when the event is disabled', async () => {
+      await ajs.register(
+        hightouch,
+        trackEvent,
+        trackPurchase,
+        updateUserProfile,
+        amplitude,
+        schemaFilter(
+          {
+            hi: {
+              enabled: true,
+              integrations: {
+                'Braze Web Mode (Actions)': false,
+              },
+            },
+          },
+          settings
+        )
+      )
+
+      await ajs.track('hi')
+
+      expect(hightouch.track).toHaveBeenCalled()
+      expect(amplitude.track).toHaveBeenCalled()
+
+      expect(trackEvent.track).not.toHaveBeenCalled()
+      expect(trackPurchase.track).not.toHaveBeenCalled()
+      expect(updateUserProfile.track).not.toHaveBeenCalled()
+    })
+
+    it('does not drop events with different names', async () => {
+      await ajs.register(
+        hightouch,
+        trackEvent,
+        trackPurchase,
+        updateUserProfile,
+        amplitude,
+        schemaFilter(
+          {
+            'Fake Track Event': {
+              enabled: true,
+              integrations: { amplitude: false },
+            },
+          },
+          settings
+        )
+      )
+
+      await ajs.track('Track Event')
+
+      expect(hightouch.track).toHaveBeenCalled()
+      expect(amplitude.track).toHaveBeenCalled()
+      expect(trackEvent.track).toHaveBeenCalled()
+      expect(trackPurchase.track).toHaveBeenCalled()
+      expect(updateUserProfile.track).toHaveBeenCalled()
+    })
+
+    it('does not drop events with same name when unplanned events are disallowed', async () => {
+      await ajs.register(
+        hightouch,
+        trackEvent,
+        trackPurchase,
+        updateUserProfile,
+        amplitude,
+        schemaFilter(
+          {
+            __default: { enabled: false, integrations: {} },
+            'Track Event': {
+              enabled: true,
+              integrations: {},
+            },
+          },
+          settings
+        )
+      )
+
+      await ajs.track('Track Event')
+
+      expect(hightouch.track).toHaveBeenCalled()
+      expect(amplitude.track).toHaveBeenCalled()
+      expect(trackEvent.track).toHaveBeenCalled()
+      expect(trackPurchase.track).toHaveBeenCalled()
+      expect(updateUserProfile.track).toHaveBeenCalled()
+    })
+
+    it('drop events with different names when unplanned events are disallowed', async () => {
+      await ajs.register(
+        hightouch,
+        trackEvent,
+        trackPurchase,
+        updateUserProfile,
+        amplitude,
+        schemaFilter(
+          {
+            __default: { enabled: false, integrations: {} },
+            'Fake Track Event': {
+              enabled: true,
+              integrations: {},
+            },
+          },
+          settings
+        )
+      )
+
+      await ajs.track('Track Event')
+
+      expect(hightouch.track).toHaveBeenCalled()
+      expect(amplitude.track).not.toHaveBeenCalled()
+      expect(trackEvent.track).not.toHaveBeenCalled()
+      expect(trackPurchase.track).not.toHaveBeenCalled()
+      expect(updateUserProfile.track).not.toHaveBeenCalled()
+    })
+
+    it('drops enabled event for matching destination', async () => {
+      await ajs.register(
+        hightouch,
+        trackEvent,
+        trackPurchase,
+        updateUserProfile,
+        amplitude,
+        schemaFilter(
+          {
+            'Track Event': {
+              enabled: true,
+              integrations: { amplitude: false },
+            },
+          },
+          settings
+        )
+      )
+
+      await ajs.track('Track Event')
+
+      expect(hightouch.track).toHaveBeenCalled()
+      expect(trackEvent.track).toHaveBeenCalled()
+      expect(trackPurchase.track).toHaveBeenCalled()
+      expect(updateUserProfile.track).toHaveBeenCalled()
+
+      expect(amplitude.track).not.toHaveBeenCalled()
+    })
+
+    it('does not drop event for non-matching destination', async () => {
+      const filterXt = schemaFilter(
+        {
+          'Track Event': {
+            enabled: true,
+            integrations: { 'not amplitude': false },
+          },
+        },
+        settings
+      )
+
+      await ajs.register(
+        hightouch,
+        trackEvent,
+        trackPurchase,
+        updateUserProfile,
+        amplitude,
+        filterXt
+      )
+
+      await ajs.track('Track Event')
+
+      expect(hightouch.track).toHaveBeenCalled()
+      expect(trackEvent.track).toHaveBeenCalled()
+      expect(trackPurchase.track).toHaveBeenCalled()
+      expect(updateUserProfile.track).toHaveBeenCalled()
+      expect(amplitude.track).toHaveBeenCalled()
+    })
+
+    it('does not drop enabled event with enabled destination', async () => {
+      const filterXt = schemaFilter(
+        {
+          'Track Event': {
+            enabled: true,
+            integrations: { amplitude: true },
+          },
+        },
+        settings
+      )
+
+      await ajs.register(
+        hightouch,
+        trackEvent,
+        trackPurchase,
+        updateUserProfile,
+        amplitude,
+        filterXt
+      )
+
+      await ajs.track('Track Event')
+
+      expect(hightouch.track).toHaveBeenCalled()
+      expect(trackEvent.track).toHaveBeenCalled()
+      expect(trackPurchase.track).toHaveBeenCalled()
+      expect(updateUserProfile.track).toHaveBeenCalled()
+      expect(amplitude.track).toHaveBeenCalled()
+    })
+
+    it('properly sets event integrations object with enabled plan', async () => {
+      const filterXt = schemaFilter(
+        {
+          'Track Event': {
+            enabled: true,
+            integrations: { amplitude: true },
+          },
+        },
+        settings
+      )
+
+      await ajs.register(
+        hightouch,
+        trackEvent,
+        trackPurchase,
+        updateUserProfile,
+        amplitude,
+        filterXt
+      )
+
+      const ctx = await ajs.track('Track Event')
+
+      expect(ctx.event.integrations).toEqual({ amplitude: true })
+      expect(hightouch.track).toHaveBeenCalled()
+    })
+
+    it('sets event integrations object when integration is disabled', async () => {
+      const filterXt = schemaFilter(
+        {
+          'Track Event': {
+            enabled: true,
+            integrations: { amplitude: false },
+          },
+        },
+        settings
+      )
+
+      await ajs.register(
+        hightouch,
+        trackEvent,
+        trackPurchase,
+        updateUserProfile,
+        amplitude,
+        filterXt
+      )
+
+      const ctx = await ajs.track('Track Event')
+
+      expect(hightouch.track).toHaveBeenCalled()
+      expect(trackEvent.track).toHaveBeenCalled()
+      expect(trackPurchase.track).toHaveBeenCalled()
+      expect(updateUserProfile.track).toHaveBeenCalled()
+
+      expect(amplitude.track).not.toHaveBeenCalled()
+      expect(ctx.event.integrations).toEqual({ amplitude: false })
+    })
+
+    it('doesnt set event integrations object with different event', async () => {
+      const filterXt = schemaFilter(
+        {
+          'Track Event': {
+            enabled: true,
+            integrations: { amplitude: true },
+          },
+        },
+        settings
+      )
+
+      await ajs.register(
+        hightouch,
+        trackEvent,
+        trackPurchase,
+        updateUserProfile,
+        amplitude,
+        filterXt
+      )
+
+      const ctx = await ajs.track('Not Track Event')
+
+      expect(ctx.event.integrations).toEqual({})
+    })
+  })
+
+  describe('action destinations', () => {
+    it('disables action destinations', async () => {
+      const filterXt = schemaFilter(
+        {
+          'Track Event': {
+            enabled: true,
+            integrations: {
+              'Braze Web Mode (Actions)': false,
+            },
+          },
+          __default: {
+            enabled: true,
+            integrations: {},
+          },
+          hi: {
+            enabled: true,
+            integrations: {
+              'Braze Web Mode (Actions)': false,
+            },
+          },
+        },
+        settings
+      )
+
+      await ajs.register(
+        hightouch,
+        trackEvent,
+        trackPurchase,
+        updateUserProfile,
+        amplitude,
+        filterXt
+      )
+
+      await ajs.track('Track Event')
+
+      expect(hightouch.track).toHaveBeenCalled()
+      expect(amplitude.track).toHaveBeenCalled()
+
+      expect(trackEvent.track).not.toHaveBeenCalled()
+      expect(trackPurchase.track).not.toHaveBeenCalled()
+      expect(updateUserProfile.track).not.toHaveBeenCalled()
+
+      await ajs.track('a non blocked event')
+
+      expect(hightouch.track).toHaveBeenCalled()
+      expect(amplitude.track).toHaveBeenCalled()
+
+      expect(trackEvent.track).toHaveBeenCalled()
+      expect(trackPurchase.track).toHaveBeenCalled()
+      expect(updateUserProfile.track).toHaveBeenCalled()
+    })
+
+    it('covers different names between remote plugins and integrations', async () => {
+      const filterXt = schemaFilter(
+        {
+          hi: {
+            enabled: true,
+            integrations: {
+              // note that Fullstory's name here does not contain 'Actions'
+              Fullstory: false,
+            },
+          },
+        },
+        settings
+      )
+
+      await ajs.register(
+        hightouch,
+        trackEvent,
+        trackPurchase,
+        updateUserProfile,
+        amplitude,
+        fullstory,
+        filterXt
+      )
+
+      await ajs.track('hi')
+
+      expect(hightouch.track).toHaveBeenCalled()
+      expect(amplitude.track).toHaveBeenCalled()
+      expect(trackEvent.track).toHaveBeenCalled()
+      expect(trackPurchase.track).toHaveBeenCalled()
+      expect(updateUserProfile.track).toHaveBeenCalled()
+
+      expect(fullstory.track).not.toHaveBeenCalled()
+
+      await ajs.track('a non blocked event')
+
+      expect(hightouch.track).toHaveBeenCalled()
+      expect(amplitude.track).toHaveBeenCalled()
+
+      expect(trackEvent.track).toHaveBeenCalled()
+      expect(trackPurchase.track).toHaveBeenCalled()
+      expect(updateUserProfile.track).toHaveBeenCalled()
+      expect(fullstory.track).toHaveBeenCalled()
+    })
+  })
+})

package/packages/browser/src/plugins/schema-filter/index.ts

@@ -0,0 +1,90 @@
+import { LegacySettings } from '../../browser'
+import { Context } from '../../core/context'
+import { PlanEvent, TrackPlan } from '../../core/events/interfaces'
+import { Plugin } from '../../core/plugin'
+import { isPlanEventEnabled } from '../../lib/is-plan-event-enabled'
+import { RemotePlugin } from '../remote-loader'
+
+function disabledActionDestinations(
+  plan: PlanEvent | undefined,
+  settings: LegacySettings
+): { [destination: string]: string[] } {
+  if (!plan || !Object.keys(plan)) {
+    return {}
+  }
+
+  const disabledIntegrations = plan.integrations
+    ? Object.keys(plan.integrations).filter(
+        (i) => plan.integrations![i] === false
+      )
+    : []
+
+  // This accounts for cases like Fullstory, where the settings.integrations
+  // contains a "Fullstory" object but settings.remotePlugins contains "Fullstory (Actions)"
+  const disabledRemotePlugins: string[] = []
+  ;(settings.remotePlugins ?? []).forEach((p: RemotePlugin) => {
+    disabledIntegrations.forEach((int) => {
+      if (p.name.includes(int) || int.includes(p.name)) {
+        disabledRemotePlugins.push(p.name)
+      }
+    })
+  })
+
+  return (settings.remotePlugins ?? []).reduce((acc, p) => {
+    if (p.settings['subscriptions']) {
+      if (disabledRemotePlugins.includes(p.name)) {
+        // @ts-expect-error element implicitly has an 'any' type because p.settings is a JSONObject
+        p.settings['subscriptions'].forEach(
+          // @ts-expect-error parameter 'sub' implicitly has an 'any' type
+          (sub) => (acc[`${p.name} ${sub.partnerAction}`] = false)
+        )
+      }
+    }
+    return acc
+  }, {})
+}
+
+export function schemaFilter(
+  track: TrackPlan | undefined,
+  settings: LegacySettings
+): Plugin {
+  function filter(ctx: Context): Context {
+    const plan = track
+    const ev = ctx.event.event
+
+    if (plan && ev) {
+      const planEvent = plan[ev]
+      if (!isPlanEventEnabled(plan, planEvent)) {
+        ctx.updateEvent('integrations', {
+          ...ctx.event.integrations,
+          All: false,
+          'Hightouch.io': true,
+        })
+        return ctx
+      } else {
+        const disabledActions = disabledActionDestinations(planEvent, settings)
+
+        ctx.updateEvent('integrations', {
+          ...ctx.event.integrations,
+          ...planEvent?.integrations,
+          ...disabledActions,
+        })
+      }
+    }
+
+    return ctx
+  }
+
+  return {
+    name: 'Schema Filter',
+    version: '0.1.0',
+    isLoaded: () => true,
+    load: () => Promise.resolve(),
+    type: 'before',
+    page: filter,
+    alias: filter,
+    track: filter,
+    identify: filter,
+    group: filter,
+  }
+}

package/packages/browser/src/plugins/validation/__tests__/index.test.ts

@@ -0,0 +1,78 @@
+import { validation } from '..'
+import { Context } from '../../../core/context'
+import { HightouchEvent } from '../../../core/events'
+
+const validEvent: HightouchEvent = {
+  type: 'track',
+  anonymousId: 'abc',
+  event: 'test',
+  properties: {},
+  traits: {},
+}
+
+describe('validation', () => {
+  ;['track', 'identify', 'group', 'page', 'alias'].forEach((method) => {
+    // @ts-ignore
+    const validationFn: Function = validation[method] as any
+    describe(method, () => {
+      it('validates that the `event` exists', async () => {
+        try {
+          // @ts-ignore
+          await validationFn(new Context())
+        } catch (err) {
+          expect(err).toBeTruthy()
+        }
+        expect.assertions(1)
+      })
+
+      it('validates that `event.event` exists', async () => {
+        if (method === 'track') {
+          try {
+            await validationFn(
+              new Context({
+                ...validEvent,
+                event: undefined,
+              })
+            )
+          } catch (err) {
+            expect(err).toBeTruthy()
+          }
+          expect.assertions(1)
+        }
+      })
+
+      it('validates that `properties` or `traits` are objects', async () => {
+        if (method === 'alias') {
+          return
+        }
+        try {
+          await validationFn(
+            new Context({
+              ...validEvent,
+              properties: undefined,
+              traits: undefined,
+            })
+          )
+        } catch (err) {
+          expect(err).toBeTruthy()
+        }
+        expect.assertions(1)
+      })
+
+      it('validates that it contains an user', async () => {
+        try {
+          await validationFn(
+            new Context({
+              ...validEvent,
+              userId: undefined,
+              anonymousId: undefined,
+            })
+          )
+        } catch (err) {
+          expect(err).toBeTruthy()
+        }
+        expect.assertions(1)
+      })
+    })
+  })
+})