utneque 1.0.0

package/packages/browser/src/plugins/remote-loader/index.ts

@@ -0,0 +1,256 @@
+import type { Integrations } from '../../core/events/interfaces'
+import { LegacySettings } from '../../browser'
+import { JSONObject, JSONValue } from '../../core/events'
+import { DestinationPlugin, Plugin } from '../../core/plugin'
+import { loadScript } from '../../lib/load-script'
+import { getCDN } from '../../lib/parse-cdn'
+import {
+  applyDestinationMiddleware,
+  DestinationMiddlewareFunction,
+} from '../middleware'
+import { Context, ContextCancelation } from '../../core/context'
+import { Analytics } from '../../core/analytics'
+
+export interface RemotePlugin {
+  /** The name of the remote plugin */
+  name: string
+  /** The creation name of the remote plugin */
+  creationName: string
+  /** The url of the javascript file to load */
+  url: string
+  /** The UMD/global name the plugin uses. Plugins are expected to exist here with the `PluginFactory` method signature */
+  libraryName: string
+  /** The settings related to this plugin. */
+  settings: JSONObject
+}
+
+export class ActionDestination implements DestinationPlugin {
+  name: string // destination name
+  version = '1.0.0'
+  type: Plugin['type']
+
+  alternativeNames: string[] = []
+
+  middleware: DestinationMiddlewareFunction[] = []
+
+  action: Plugin
+
+  constructor(name: string, action: Plugin) {
+    this.action = action
+    this.name = name
+    this.type = action.type
+    this.alternativeNames.push(action.name)
+  }
+
+  addMiddleware(...fn: DestinationMiddlewareFunction[]): void {
+    if (this.type === 'destination') {
+      this.middleware.push(...fn)
+    }
+  }
+
+  private async transform(ctx: Context): Promise<Context> {
+    const modifiedEvent = await applyDestinationMiddleware(
+      this.name,
+      ctx.event,
+      this.middleware
+    )
+
+    if (modifiedEvent === null) {
+      ctx.cancel(
+        new ContextCancelation({
+          retry: false,
+          reason: 'dropped by destination middleware',
+        })
+      )
+    }
+
+    return new Context(modifiedEvent!)
+  }
+
+  private _createMethod(
+    methodName: 'track' | 'page' | 'identify' | 'alias' | 'group' | 'screen'
+  ) {
+    return async (ctx: Context): Promise<Context> => {
+      if (!this.action[methodName]) return ctx
+
+      let transformedContext: Context = ctx
+      // Transformations only allowed for destination plugins. Other plugin types support mutating events.
+      if (this.type === 'destination') {
+        transformedContext = await this.transform(ctx)
+      }
+
+      await this.action[methodName]!(transformedContext)
+
+      return ctx
+    }
+  }
+
+  alias = this._createMethod('alias')
+  group = this._createMethod('group')
+  identify = this._createMethod('identify')
+  page = this._createMethod('page')
+  screen = this._createMethod('screen')
+  track = this._createMethod('track')
+
+  /* --- PASSTHROUGH METHODS --- */
+  isLoaded(): boolean {
+    return this.action.isLoaded()
+  }
+
+  ready(): Promise<unknown> {
+    return this.action.ready ? this.action.ready() : Promise.resolve()
+  }
+
+  load(ctx: Context, analytics: Analytics): Promise<unknown> {
+    return this.action.load(ctx, analytics)
+  }
+
+  unload(ctx: Context, analytics: Analytics): Promise<unknown> | unknown {
+    return this.action.unload?.(ctx, analytics)
+  }
+}
+
+export type PluginFactory = {
+  (settings: JSONValue): Plugin | Plugin[] | Promise<Plugin | Plugin[]>
+  pluginName: string
+}
+
+function validate(pluginLike: unknown): pluginLike is Plugin[] {
+  if (!Array.isArray(pluginLike)) {
+    throw new Error('Not a valid list of plugins')
+  }
+
+  const required = ['load', 'isLoaded', 'name', 'version', 'type']
+  pluginLike.forEach((plugin) => {
+    required.forEach((method) => {
+      if (plugin[method] === undefined) {
+        throw new Error(
+          `Plugin: ${
+            plugin.name ?? 'unknown'
+          } missing required function ${method}`
+        )
+      }
+    })
+  })
+
+  return true
+}
+
+function isPluginDisabled(
+  userIntegrations: Integrations,
+  remotePlugin: RemotePlugin
+) {
+  const creationNameEnabled = userIntegrations[remotePlugin.creationName]
+  const currentNameEnabled = userIntegrations[remotePlugin.name]
+
+  // Check that the plugin isn't explicitly enabled when All: false
+  if (
+    userIntegrations.All === false &&
+    !creationNameEnabled &&
+    !currentNameEnabled
+  ) {
+    return true
+  }
+
+  // Check that the plugin isn't explicitly disabled
+  if (creationNameEnabled === false || currentNameEnabled === false) {
+    return true
+  }
+
+  return false
+}
+
+async function loadPluginFactory(
+  remotePlugin: RemotePlugin,
+  obfuscate?: boolean
+): Promise<void | PluginFactory> {
+  const defaultCdn = new RegExp('https://cdn.hightouch-events.(com|build)')
+  const cdn = getCDN()
+
+  if (obfuscate) {
+    const urlSplit = remotePlugin.url.split('/')
+    const name = urlSplit[urlSplit.length - 2]
+    const obfuscatedURL = remotePlugin.url.replace(
+      name,
+      btoa(name).replace(/=/g, '')
+    )
+    try {
+      await loadScript(obfuscatedURL.replace(defaultCdn, cdn))
+    } catch (error) {
+      // Due to syncing concerns it is possible that the obfuscated action destination (or requested version) might not exist.
+      // We should use the unobfuscated version as a fallback.
+      await loadScript(remotePlugin.url.replace(defaultCdn, cdn))
+    }
+  } else {
+    await loadScript(remotePlugin.url.replace(defaultCdn, cdn))
+  }
+
+  // @ts-expect-error
+  if (typeof window[remotePlugin.libraryName] === 'function') {
+    // @ts-expect-error
+    return window[remotePlugin.libraryName] as PluginFactory
+  }
+}
+
+export async function remoteLoader(
+  settings: LegacySettings,
+  userIntegrations: Integrations,
+  mergedIntegrations: Record<string, JSONObject>,
+  obfuscate?: boolean,
+  routingMiddleware?: DestinationMiddlewareFunction,
+  pluginSources?: PluginFactory[]
+): Promise<Plugin[]> {
+  const allPlugins: Plugin[] = []
+
+  const routingRules = settings.middlewareSettings?.routingRules ?? []
+
+  const pluginPromises = (settings.remotePlugins ?? []).map(
+    async (remotePlugin) => {
+      if (isPluginDisabled(userIntegrations, remotePlugin)) return
+
+      try {
+        const pluginFactory =
+          pluginSources?.find(
+            ({ pluginName }) => pluginName === remotePlugin.name
+          ) || (await loadPluginFactory(remotePlugin, obfuscate))
+
+        if (pluginFactory) {
+          const plugin = await pluginFactory({
+            ...remotePlugin.settings,
+            ...mergedIntegrations[remotePlugin.name],
+          })
+          const plugins = Array.isArray(plugin) ? plugin : [plugin]
+
+          validate(plugins)
+
+          const routing = routingRules.filter(
+            (rule) => rule.destinationName === remotePlugin.creationName
+          )
+
+          plugins.forEach((plugin) => {
+            const wrapper = new ActionDestination(
+              remotePlugin.creationName,
+              plugin
+            )
+
+            /** Make sure we only apply destination filters to actions of the "destination" type to avoid causing issues for hybrid destinations */
+            if (
+              routing.length &&
+              routingMiddleware &&
+              plugin.type === 'destination'
+            ) {
+              wrapper.addMiddleware(routingMiddleware)
+            }
+
+            allPlugins.push(wrapper)
+          })
+        }
+      } catch (error) {
+        console.warn('Failed to load Remote Plugin', error)
+      }
+    }
+  )
+
+  await Promise.all(pluginPromises)
+  return allPlugins.filter(Boolean)
+}

package/packages/browser/src/plugins/remote-middleware/__tests__/index.test.ts

@@ -0,0 +1,116 @@
+import { remoteMiddlewares } from '..'
+import { Context } from '../../../core/context'
+import jsdom from 'jsdom'
+
+// We dont currently support remote middleware
+describe.skip('Remote Middleware', () => {
+  beforeEach(async () => {
+    jest.restoreAllMocks()
+    jest.resetAllMocks()
+
+    const html = `
+    <!DOCTYPE html>
+      <head>
+        <script>'you need me here'</script>
+      </head>
+      <body></body>
+    </html>
+    `.trim()
+
+    const jsd = new jsdom.JSDOM(html, {
+      runScripts: 'dangerously',
+      resources: 'usable',
+      url: 'https://localhost',
+    })
+
+    const windowSpy = jest.spyOn(global, 'window', 'get')
+    windowSpy.mockImplementation(
+      () => jsd.window as unknown as Window & typeof globalThis
+    )
+  })
+
+  it('ignores empty dictionaries', async () => {
+    const md = await remoteMiddlewares(Context.system(), {
+      integrations: {},
+    })
+
+    expect(md).toEqual([])
+  })
+
+  it('doesnt load entries if their value is false', async () => {
+    const md = await remoteMiddlewares(Context.system(), {
+      integrations: {},
+      enabledMiddleware: {
+        '@segment/analytics.js-middleware-braze-deduplicate': false,
+      },
+    })
+
+    expect(md).toEqual([])
+  })
+
+  it('loads middleware that exist', async () => {
+    const md = await remoteMiddlewares(Context.system(), {
+      integrations: {},
+      enabledMiddleware: {
+        '@segment/analytics.js-middleware-braze-deduplicate': true,
+      },
+    })
+
+    expect(md.length).toEqual(1)
+    expect(md[0]).toMatchInlineSnapshot(`[Function]`)
+  })
+
+  it('ignores segment namespace', async () => {
+    const md = await remoteMiddlewares(Context.system(), {
+      integrations: {},
+      enabledMiddleware: {
+        '@segment/analytics.js-middleware-braze-deduplicate': true,
+        'analytics.js-middleware-braze-deduplicate': true,
+      },
+    })
+
+    expect(md.length).toEqual(2)
+    expect(md[0]).toEqual(md[1])
+  })
+
+  it('loads middleware through remote script tags', async () => {
+    await remoteMiddlewares(Context.system(), {
+      integrations: {},
+      enabledMiddleware: {
+        '@segment/analytics.js-middleware-braze-deduplicate': true,
+      },
+    })
+
+    const sources = Array.from(window.document.querySelectorAll('script'))
+      .map((s) => s.src)
+      .filter(Boolean)
+
+    expect(sources).toMatchInlineSnapshot(`
+      Array [
+        "https://cdn.hightouch-events.com/next-integrations/middleware/analytics.js-middleware-braze-deduplicate/latest/analytics.js-middleware-braze-deduplicate.js.gz",
+      ]
+    `)
+  })
+
+  it('ignores middleware that do not exist', async () => {
+    jest.spyOn(global.console, 'error').mockImplementation()
+
+    const ctx = Context.system()
+    const md = await remoteMiddlewares(ctx, {
+      integrations: {},
+      enabledMiddleware: {
+        '@segment/analytics.js-middleware-braze-deduplicate': true,
+        '@segment/analytics.js-middleware-that-does-not-exist': true,
+      },
+    })
+
+    expect(md.length).toEqual(1)
+    expect(md[0]).toMatchInlineSnapshot(`[Function]`)
+
+    expect(ctx.logs().map((l) => l.message)).toMatchInlineSnapshot(`
+      Array [
+        [Error: Failed to load https://cdn.hightouch-events.com/next-integrations/middleware/analytics.js-middleware-that-does-not-exist/latest/analytics.js-middleware-that-does-not-exist.js.gz],
+      ]
+    `)
+  })
+})

package/packages/browser/src/plugins/remote-middleware/index.ts

@@ -0,0 +1,44 @@
+import { LegacySettings } from '../../browser'
+import { Context } from '../../core/context'
+import { isServer } from '../../core/environment'
+import { loadScript } from '../../lib/load-script'
+import { getNextIntegrationsURL } from '../../lib/parse-cdn'
+import { MiddlewareFunction } from '../middleware'
+
+export async function remoteMiddlewares(
+  ctx: Context,
+  settings: LegacySettings,
+  obfuscate?: boolean
+): Promise<MiddlewareFunction[]> {
+  if (isServer()) {
+    return []
+  }
+  const path = getNextIntegrationsURL()
+  const remoteMiddleware = settings.enabledMiddleware ?? {}
+  const names = Object.entries(remoteMiddleware)
+    .filter(([_, enabled]) => enabled)
+    .map(([name]) => name)
+
+  const scripts = names.map(async (name) => {
+    const nonNamespaced = name.replace('@segment/', '')
+    let bundleName = nonNamespaced
+    if (obfuscate) {
+      bundleName = btoa(nonNamespaced).replace(/=/g, '')
+    }
+    const fullPath = `${path}/middleware/${bundleName}/latest/${bundleName}.js.gz`
+
+    try {
+      await loadScript(fullPath)
+      // @ts-ignore
+      return window[`${nonNamespaced}Middleware`] as MiddlewareFunction
+    } catch (error: any) {
+      ctx.log('error', error)
+      ctx.stats.increment('failed_remote_middleware')
+    }
+  })
+
+  let middleware = await Promise.all(scripts)
+  middleware = middleware.filter(Boolean)
+
+  return middleware as MiddlewareFunction[]
+}

package/packages/browser/src/plugins/routing-middleware/__tests__/index.test.ts

@@ -0,0 +1,64 @@
+import { tsubMiddleware } from '..'
+import { toFacade } from '../../../lib/to-facade'
+
+describe('tsub middleware', () => {
+  const rules = [
+    {
+      matchers: [
+        {
+          ir: '["=","event",{"value":"Item Impression"}]',
+          type: 'fql',
+        },
+      ],
+      scope: 'destinations',
+      target_type: 'workspace::project::destination',
+      transformers: [[{ type: 'drop' }]],
+      destinationName: 'Google Tag Manager',
+    },
+  ]
+
+  const middleware = tsubMiddleware(rules)
+
+  it('can apply tsub operations', () => {
+    let payload
+    const next = jest.fn().mockImplementation((transformed) => {
+      payload = transformed?.obj
+    })
+
+    void middleware({
+      integration: 'Google Tag Manager',
+      next,
+      payload: toFacade({
+        type: 'track',
+        event: 'Item Impression',
+      }),
+    })
+
+    expect(next).toHaveBeenCalled()
+    expect(payload).toMatchInlineSnapshot(`null`)
+  })
+
+  it("won't match different destinations", () => {
+    let payload
+    const next = jest.fn().mockImplementation((transformed) => {
+      payload = transformed?.obj
+    })
+
+    void middleware({
+      integration: 'Google Analytics',
+      next,
+      payload: toFacade({
+        type: 'track',
+        event: 'Item Impression',
+      }),
+    })
+
+    expect(next).toHaveBeenCalled()
+    expect(payload).toMatchInlineSnapshot(`
+      Object {
+        "event": "Item Impression",
+        "type": "track",
+      }
+    `)
+  })
+})

package/packages/browser/src/plugins/routing-middleware/index.ts

@@ -0,0 +1,37 @@
+import * as tsub from '@segment/tsub'
+import { Matcher, Rule } from '@segment/tsub/dist/store'
+import { DestinationMiddlewareFunction } from '../middleware'
+
+// TODO: update tsub definition
+type RoutingRuleMatcher = Matcher & {
+  config?: {
+    expr: string
+  }
+}
+
+export type RoutingRule = Rule & {
+  matchers: RoutingRuleMatcher[]
+}
+
+export const tsubMiddleware =
+  (rules: RoutingRule[]): DestinationMiddlewareFunction =>
+  ({ payload, integration, next }): void => {
+    const store = new tsub.Store(rules)
+    const rulesToApply = store.getRulesByDestinationName(integration)
+
+    rulesToApply.forEach((rule) => {
+      const { matchers, transformers } = rule
+
+      for (let i = 0; i < matchers.length; i++) {
+        if (tsub.matches(payload.obj, matchers[i])) {
+          payload.obj = tsub.transform(payload.obj, transformers[i])
+
+          if (payload.obj === null) {
+            return next(null)
+          }
+        }
+      }
+    })
+
+    next(payload)
+  }