npm - utneque - Versions diffs - 1.0.0 - Mend

utneque 1.0.0

Files changed (431) hide show

package/packages/browser/src/plugins/legacy-video-plugins/__tests__/index.test.ts ADDED Viewed

@@ -0,0 +1,48 @@
+import { JSDOM } from 'jsdom'
+import { Analytics } from '../../../core/analytics'
+import { loadLegacyVideoPlugins } from '../index'
+beforeEach(async () => {
+  jest.restoreAllMocks()
+  jest.resetAllMocks()
+  const html = `
+    <!DOCTYPE html>
+      <head>
+        <script>
+          'hi'
+        </script>
+      </head>
+      <body>
+      </body>
+    </html>
+    `.trim()
+  const jsd = new JSDOM(html, {
+    runScripts: 'dangerously',
+    resources: 'usable',
+  })
+  const windowSpy = jest.spyOn(global, 'window', 'get')
+  windowSpy.mockImplementation(() => {
+    return jsd.window as unknown as Window & typeof globalThis
+  })
+})
+describe(loadLegacyVideoPlugins.name, () => {
+  it('attaches video plugins to ajs', async () => {
+    console.warn = () => {}
+    const ajs = new Analytics({
+      writeKey: 'w_123',
+    })
+    await loadLegacyVideoPlugins(ajs)
+    expect(ajs.plugins).toMatchInlineSnapshot(`
+      Object {
+        "VimeoAnalytics": [Function],
+        "YouTubeAnalytics": [Function],
+      }
+    `)
+  })
+})

package/packages/browser/src/plugins/legacy-video-plugins/index.ts ADDED Viewed

@@ -0,0 +1,16 @@
+import { Analytics } from '../../core/analytics'
+export async function loadLegacyVideoPlugins(
+  htevents: Analytics
+): Promise<void> {
+  const plugins = await import(
+    // @ts-expect-error
+    '@segment/analytics.js-video-plugins/dist/index.umd.js'
+  )
+  // This is super gross, but we need to support the `window.htevents.plugins` namespace
+  // that is linked in the hightouch docs in order to be backwards compatible with ajs-classic
+  // @ts-expect-error
+  htevents._plugins = plugins
+}

package/packages/browser/src/plugins/middleware/__tests__/index.test.ts ADDED Viewed

@@ -0,0 +1,268 @@
+import {
+  DestinationMiddlewareFunction,
+  MiddlewareFunction,
+  sourceMiddlewarePlugin,
+} from '..'
+import { Analytics } from '../../../core/analytics'
+import { Context } from '../../../core/context'
+import { Plugin } from '../../../core/plugin'
+import { LegacyDestination } from '../../ajs-destination'
+describe(sourceMiddlewarePlugin, () => {
+  const simpleMiddleware: MiddlewareFunction = ({ payload, next }) => {
+    if (!payload.obj.context) {
+      payload.obj.context = {}
+    }
+    payload.obj.context.hello = 'from the other side'
+    next(payload)
+  }
+  const xt = sourceMiddlewarePlugin(simpleMiddleware, {})
+  it('creates a source middleware', () => {
+    expect(xt.name).toEqual('Source Middleware simpleMiddleware')
+    expect(xt.version).toEqual('0.1.0')
+  })
+  it('is loaded automatically', async () => {
+    // @ts-expect-error
+    expect(await xt.load(Context.system())).toBeTruthy()
+    expect(xt.isLoaded()).toBe(true)
+  })
+  describe('Middleware', () => {
+    it('allows for changing the event', async () => {
+      const changeProperties: MiddlewareFunction = ({ payload, next }) => {
+        if (!payload.obj.properties) {
+          payload.obj.properties = {}
+        }
+        payload.obj.properties.hello = 'from the other side'
+        next(payload)
+      }
+      const xt = sourceMiddlewarePlugin(changeProperties, {})
+      expect(
+        (
+          await xt.track!(
+            new Context({
+              type: 'track',
+            })
+          )
+        ).event.properties
+      ).toEqual({
+        hello: 'from the other side',
+      })
+    })
+    it('uses a segment facade object', async () => {
+      let type = ''
+      const facadeMiddleware: MiddlewareFunction = ({ payload, next }) => {
+        type = payload.type()
+        next(payload)
+      }
+      const xt = sourceMiddlewarePlugin(facadeMiddleware, {})
+      await xt.track!(
+        new Context({
+          type: 'track',
+        })
+      )
+      expect(type).toEqual(type)
+    })
+    it('cancels the event if `next` is not called', async () => {
+      const hangs: MiddlewareFunction = () => {}
+      const hangsXT = sourceMiddlewarePlugin(hangs, {})
+      const doesNotHang: MiddlewareFunction = ({ next, payload }) => {
+        next(payload)
+      }
+      const doesNotHangXT = sourceMiddlewarePlugin(doesNotHang, {})
+      const toReturn = new Context({ type: 'track' })
+      const returnedCtx = await doesNotHangXT.track!(toReturn)
+      expect(returnedCtx).toBe(toReturn)
+      const toCancel = new Context({ type: 'track' })
+      try {
+        await hangsXT.track!(toCancel)
+        throw new Error('should not reach here.')
+      } catch (err) {
+        expect(err).toMatchInlineSnapshot(`
+          ContextCancelation {
+            "reason": "Middleware \`next\` function skipped",
+            "retry": false,
+            "type": "middleware_cancellation",
+          }
+        `)
+      }
+    })
+  })
+  describe('Destination Middleware', () => {
+    it('doesnt modify original context', async () => {
+      const changeProperties: DestinationMiddlewareFunction = ({
+        payload,
+        next,
+      }) => {
+        if (!payload.obj.properties) {
+          payload.obj.properties = {}
+        }
+        payload.obj.properties.hello = 'from the other side'
+        next(payload)
+      }
+      const dest = new LegacyDestination(
+        'Google Analytics',
+        'latest',
+        'writeKey',
+        {},
+        {}
+      )
+      const ctx = new Context({
+        type: 'track',
+        event: 'Foo',
+        properties: {
+          hello: 'from this side',
+        },
+      })
+      dest.addMiddleware(changeProperties)
+      await dest.track(ctx)
+      expect(ctx.event.properties!.hello).toEqual('from this side')
+    })
+  })
+  describe('Common use cases', () => {
+    it('can be used to cancel an event altogether', async () => {
+      const blowUp: MiddlewareFunction = () => {
+        // do nothing
+        // do not invoke next
+      }
+      const ajs = new Analytics({
+        writeKey: 'abc',
+      })
+      const ctx = await ajs.page('hello')
+      expect(ctx.logs().map((l) => l.message)).toContain('Delivered')
+      await ajs.addSourceMiddleware(blowUp)
+      const notDelivered = await ajs.page('hello')
+      expect(notDelivered.logs().map((l) => l.message)).not.toContain(
+        'Delivered'
+      )
+    })
+    it('can be used to re-route/cancel destinations', async () => {
+      let middlewareInvoked = false
+      const pageMock = jest.fn()
+      const skipGA: MiddlewareFunction = ({ payload, next }) => {
+        if (!payload.obj.integrations) {
+          payload.obj.integrations = {}
+        }
+        payload.obj.integrations['Google Analytics'] = false
+        middlewareInvoked = true
+        next(payload)
+      }
+      const gaDestination: Plugin = {
+        name: 'Google Analytics',
+        isLoaded: () => true,
+        load: async () => {},
+        type: 'destination',
+        version: '1.0',
+        page: async (ctx) => {
+          pageMock()
+          return ctx
+        },
+      }
+      const ajs = new Analytics({
+        writeKey: 'abc',
+      })
+      await ajs.register(gaDestination)
+      await ajs.page('hello')
+      expect(pageMock).toHaveBeenCalled()
+      await ajs.addSourceMiddleware(skipGA)
+      await ajs.page('hello')
+      expect(middlewareInvoked).toBe(true)
+      expect(pageMock).toHaveBeenCalledTimes(1)
+    })
+  })
+  describe('Event API', () => {
+    it('wraps track', async () => {
+      const evt = new Context({
+        type: 'track',
+      })
+      expect((await xt.track!(evt)).event.context).toMatchInlineSnapshot(`
+        Object {
+          "hello": "from the other side",
+        }
+      `)
+    })
+    it('wraps identify', async () => {
+      const evt = new Context({
+        type: 'identify',
+      })
+      expect((await xt.identify!(evt)).event.context).toMatchInlineSnapshot(`
+        Object {
+          "hello": "from the other side",
+        }
+      `)
+    })
+    it('wraps page', async () => {
+      const evt = new Context({
+        type: 'page',
+      })
+      expect((await xt.page!(evt)).event.context).toMatchInlineSnapshot(`
+        Object {
+          "hello": "from the other side",
+        }
+      `)
+    })
+    it('wraps group', async () => {
+      const evt = new Context({
+        type: 'group',
+      })
+      expect((await xt.group!(evt)).event.context).toMatchInlineSnapshot(`
+        Object {
+          "hello": "from the other side",
+        }
+      `)
+    })
+    it('wraps alias', async () => {
+      const evt = new Context({
+        type: 'alias',
+      })
+      expect((await xt.alias!(evt)).event.context).toMatchInlineSnapshot(`
+        Object {
+          "hello": "from the other side",
+        }
+      `)
+    })
+  })
+})

package/packages/browser/src/plugins/middleware/index.ts ADDED Viewed

@@ -0,0 +1,131 @@
+import { Context, ContextCancelation } from '../../core/context'
+import { HightouchEvent } from '../../core/events'
+import { Plugin } from '../../core/plugin'
+import { SegmentFacade, toFacade } from '../../lib/to-facade'
+export interface MiddlewareParams {
+  payload: SegmentFacade
+  integrations?: HightouchEvent['integrations']
+  next: (payload: MiddlewareParams['payload'] | null) => void
+}
+export interface DestinationMiddlewareParams {
+  payload: SegmentFacade
+  integration: string
+  next: (payload: MiddlewareParams['payload'] | null) => void
+}
+export type MiddlewareFunction = (
+  middleware: MiddlewareParams
+) => void | Promise<void>
+export type DestinationMiddlewareFunction = (
+  middleware: DestinationMiddlewareParams
+) => void | Promise<void>
+export async function applyDestinationMiddleware(
+  destination: string,
+  evt: HightouchEvent,
+  middleware: DestinationMiddlewareFunction[]
+): Promise<HightouchEvent | null> {
+  // Clone the event so mutations are localized to a single destination.
+  let modifiedEvent = toFacade(evt, {
+    clone: true,
+    traverse: false,
+  }).rawEvent() as HightouchEvent
+  async function applyMiddleware(
+    event: HightouchEvent,
+    fn: DestinationMiddlewareFunction
+  ): Promise<HightouchEvent | null> {
+    let nextCalled = false
+    let returnedEvent: HightouchEvent | null = null
+    await fn({
+      payload: toFacade(event, {
+        clone: true,
+        traverse: false,
+      }),
+      integration: destination,
+      next(evt) {
+        nextCalled = true
+        if (evt === null) {
+          returnedEvent = null
+        }
+        if (evt) {
+          returnedEvent = evt.obj
+        }
+      },
+    })
+    if (!nextCalled && returnedEvent !== null) {
+      returnedEvent = returnedEvent as HightouchEvent
+      returnedEvent.integrations = {
+        ...event.integrations,
+        [destination]: false,
+      }
+    }
+    return returnedEvent
+  }
+  for (const md of middleware) {
+    const result = await applyMiddleware(modifiedEvent, md)
+    if (result === null) {
+      return null
+    }
+    modifiedEvent = result
+  }
+  return modifiedEvent
+}
+export function sourceMiddlewarePlugin(
+  fn: MiddlewareFunction,
+  integrations: HightouchEvent['integrations']
+): Plugin {
+  async function apply(ctx: Context): Promise<Context> {
+    let nextCalled = false
+    await fn({
+      payload: toFacade(ctx.event, {
+        clone: true,
+        traverse: false,
+      }),
+      integrations: integrations ?? {},
+      next(evt) {
+        nextCalled = true
+        if (evt) {
+          ctx.event = evt.obj
+        }
+      },
+    })
+    if (!nextCalled) {
+      throw new ContextCancelation({
+        retry: false,
+        type: 'middleware_cancellation',
+        reason: 'Middleware `next` function skipped',
+      })
+    }
+    return ctx
+  }
+  return {
+    name: `Source Middleware ${fn.name}`,
+    type: 'before',
+    version: '0.1.0',
+    isLoaded: (): boolean => true,
+    load: (ctx): Promise<Context> => Promise.resolve(ctx),
+    track: apply,
+    page: apply,
+    identify: apply,
+    alias: apply,
+    group: apply,
+  }
+}