@customerio/cdp-analytics-browser 0.0.0-test-oidc

package/src/plugins/in-app-plugin/index.ts

@@ -0,0 +1,241 @@
+import { Analytics } from '../../core/analytics'
+import { Context } from '../../core/context'
+import { Plugin } from '../../core/plugin'
+
+import {
+  InAppEvents,
+  JourneysEvents,
+  newEvent,
+  allEvents,
+  gistToCIO,
+  ContentType,
+} from './events'
+import Gist from 'customerio-gist-web'
+
+export { InAppEvents }
+
+export type InAppPluginSettings = {
+  siteId: string | undefined
+  events: EventListenerOrEventListenerObject | null | undefined
+
+  _env: string | undefined
+  _logging: boolean | undefined
+
+  anonymousInApp: boolean | false
+}
+
+export function InAppPlugin(settings: InAppPluginSettings): Plugin {
+  let _analytics: Analytics
+  let _gistLoaded = false
+  let _pluginLoaded = false
+  const _eventTarget: EventTarget = new EventTarget()
+
+  async function setAnonymousId() {
+    const anonymousId = _analytics.user().anonymousId()
+    if (anonymousId) {
+      await Gist.setCustomAttribute('cio_anonymous_id', anonymousId)
+    }
+  }
+
+  function attachListeners() {
+    if (!_gistLoaded || _pluginLoaded) return
+
+    _analytics.on('reset', reset)
+
+    if (settings.events) {
+      allEvents.forEach((event) => {
+        _eventTarget.addEventListener(
+          event,
+          settings?.events as EventListenerOrEventListenerObject
+        )
+      })
+      ;['messageDismissed', 'messageError'].forEach((event) => {
+        Gist.events.on(event, (message: any) => {
+          _eventTarget.dispatchEvent(
+            newEvent(gistToCIO(event), {
+              messageId: message.messageId,
+              deliveryId: message.properties?.gist?.campaignId,
+            })
+          )
+        })
+      })
+    }
+
+    Gist.events.on('messageShown', (message: any) => {
+      const deliveryId: string = message?.properties?.gist?.campaignId
+      if (settings.events) {
+        _eventTarget.dispatchEvent(
+          newEvent(InAppEvents.MessageOpened, {
+            messageId: message?.messageId,
+            deliveryId: deliveryId,
+            message: {
+              dismiss: function () {
+                Gist.dismissMessage(message?.instanceId)
+              },
+            },
+          })
+        )
+      }
+      if (typeof deliveryId !== 'undefined' && deliveryId !== '') {
+        void _analytics.track(JourneysEvents.Metric, {
+          deliveryId: deliveryId,
+          metric: JourneysEvents.Opened,
+        })
+        return
+      }
+      const broadcastId: Number =
+        message?.properties?.gist?.broadcast?.broadcastIdInt
+      if (broadcastId) {
+        const templateId = message?.properties?.gist?.broadcast?.templateId
+        void _analytics.track(JourneysEvents.Content, {
+          actionType: JourneysEvents.ViewedContent,
+          contentId: broadcastId,
+          templateId: templateId,
+          contentType: ContentType,
+        })
+      }
+    })
+
+    Gist.events.on('messageAction', (params: any) => {
+      const deliveryId: string = params?.message?.properties?.gist?.campaignId
+      if (settings.events) {
+        _eventTarget.dispatchEvent(
+          newEvent(InAppEvents.MessageAction, {
+            messageId: params.message.messageId,
+            deliveryId: deliveryId,
+            action: params.action,
+            name: params.name,
+            actionName: params.name,
+            actionValue: params.action,
+            message: {
+              dismiss: function () {
+                Gist.dismissMessage(params.message.instanceId)
+              },
+            },
+          })
+        )
+      }
+      if (params.action === 'gist://close') {
+        return
+      }
+      if (typeof deliveryId !== 'undefined' && deliveryId !== '') {
+        void _analytics.track(JourneysEvents.Metric, {
+          deliveryId: deliveryId,
+          metric: JourneysEvents.Clicked,
+          actionName: params.name,
+          actionValue: params.action,
+        })
+        return
+      }
+      const broadcastId: Number =
+        params?.message?.properties?.gist?.broadcast?.broadcastIdInt
+      if (broadcastId) {
+        const templateId: Number =
+          params?.message?.properties?.gist?.broadcast?.templateId
+        void _analytics.track(JourneysEvents.Content, {
+          actionType: JourneysEvents.ClickedContent,
+          contentId: broadcastId,
+          templateId: templateId,
+          contentType: ContentType,
+          actionName: params.name,
+          actionValue: params.action,
+        })
+      }
+    })
+
+    Gist.events.on('eventDispatched', (gistEvent: any) => {
+      if (gistEvent.name === 'analytics:track') {
+        const trackEventName: string = gistEvent.payload?.event
+        if (typeof trackEventName === 'undefined' || trackEventName === '') {
+          return
+        }
+        void _analytics.track(
+          trackEventName,
+          gistEvent.payload?.properties,
+          gistEvent.payload?.options
+        )
+      }
+    })
+  }
+
+  function page(ctx: Context): Context {
+    if (!_pluginLoaded) return ctx
+
+    const page: string =
+      ctx.event?.properties?.name ?? ctx.event?.properties?.url
+    if (typeof page === 'string' && page.length > 0) {
+      Gist.setCurrentRoute(page)
+    }
+
+    return ctx
+  }
+
+  async function reset(ctx: Context): Promise<Context> {
+    await Gist.clearUserToken()
+    await Gist.clearCustomAttributes()
+    await setAnonymousId()
+    return ctx
+  }
+
+  async function syncUserToken(ctx: Context): Promise<Context> {
+    if (!_gistLoaded) return ctx
+
+    const user = _analytics.user().id()
+    if (typeof user === 'string' && user.length > 0) {
+      await Gist.setUserToken(user)
+    } else {
+      await Gist.clearUserToken()
+    }
+    return ctx
+  }
+
+  const customerio: Plugin = {
+    name: 'Customer.io In-App Plugin',
+    type: 'before',
+    version: '0.0.1',
+    isLoaded: (): boolean => _pluginLoaded,
+    load: async (ctx: Context, instance: Analytics) => {
+      _analytics = instance
+
+      if (settings.siteId == null || settings.siteId === '') {
+        _error("siteId is required. Can't initialize.")
+        return ctx
+      }
+
+      await setAnonymousId()
+
+      await Gist.setup({
+        siteId: settings.siteId,
+        env: settings._env ? settings._env : 'prod',
+        logging: settings._logging,
+        useAnonymousSession: settings.anonymousInApp,
+      })
+      _gistLoaded = true
+
+      await syncUserToken(ctx)
+      attachListeners()
+
+      _pluginLoaded = true
+
+      return Promise.resolve()
+    },
+    identify: syncUserToken,
+    page: page,
+    unload: () => {
+      if (settings.events) {
+        allEvents.forEach((event) => {
+          _eventTarget.removeEventListener(
+            event,
+            settings?.events as EventListenerOrEventListenerObject
+          )
+        })
+      }
+    },
+  }
+
+  return customerio
+}
+
+function _error(msg: string) {
+  console.error(`[Customer.io In-App Plugin] ${msg}`)
+}

package/src/plugins/legacy-video-plugins/index.ts

@@ -0,0 +1,16 @@
+import { Analytics } from '../../core/analytics'
+
+export async function loadLegacyVideoPlugins(
+  analytics: 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.analytics.plugins` namespace
+  // that is linked in the docs in order to be backwards compatible with ajs-classic
+
+  // @ts-expect-error
+  analytics._plugins = plugins
+}

package/src/plugins/middleware/index.ts

@@ -0,0 +1,131 @@
+import { Context, ContextCancelation } from '../../core/context'
+import { CustomerioEvent } from '../../core/events'
+import { Plugin } from '../../core/plugin'
+import { CustomerioFacade, toFacade } from '../../lib/to-facade'
+
+export interface MiddlewareParams {
+  payload: CustomerioFacade
+
+  integrations?: CustomerioEvent['integrations']
+  next: (payload: MiddlewareParams['payload'] | null) => void
+}
+
+export interface DestinationMiddlewareParams {
+  payload: CustomerioFacade
+  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: CustomerioEvent,
+  middleware: DestinationMiddlewareFunction[]
+): Promise<CustomerioEvent | null> {
+  // Clone the event so mutations are localized to a single destination.
+  let modifiedEvent = toFacade(evt, {
+    clone: true,
+    traverse: false,
+  }).rawEvent() as CustomerioEvent
+  async function applyMiddleware(
+    event: CustomerioEvent,
+    fn: DestinationMiddlewareFunction
+  ): Promise<CustomerioEvent | null> {
+    let nextCalled = false
+    let returnedEvent: CustomerioEvent | 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 CustomerioEvent
+      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: CustomerioEvent['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,
+  }
+}

package/src/plugins/page-enrichment/index.ts

@@ -0,0 +1,127 @@
+import type { Context } from '../../core/context'
+import type { Plugin } from '../../core/plugin'
+
+interface PageDefault {
+  [key: string]: unknown
+  path: string
+  referrer: string
+  search: string
+  title: string
+  url: string
+}
+
+/**
+ * Get the current page's canonical URL.
+ *
+ * @return {string|undefined}
+ */
+function canonical(): string {
+  const tags = document.getElementsByTagName('link')
+  let canon: string | null = ''
+
+  Array.prototype.slice.call(tags).forEach((tag) => {
+    if (tag.getAttribute('rel') === 'canonical') {
+      canon = tag.getAttribute('href')
+    }
+  })
+
+  return canon
+}
+
+/**
+ * Return the canonical path for the page.
+ */
+
+function canonicalPath(): string {
+  const canon = canonical()
+  if (!canon) {
+    return window.location.pathname
+  }
+
+  const a = document.createElement('a')
+  a.href = canon
+  const pathname = !a.pathname.startsWith('/') ? '/' + a.pathname : a.pathname
+
+  return pathname
+}
+
+/**
+ * Return the canonical URL for the page concat the given `search`
+ * and strip the hash.
+ */
+
+export function canonicalUrl(search = ''): string {
+  const canon = canonical()
+  if (canon) {
+    return canon.includes('?') ? canon : `${canon}${search}`
+  }
+  const url = window.location.href
+  const i = url.indexOf('#')
+  return i === -1 ? url : url.slice(0, i)
+}
+
+/**
+ * Return a default `options.context.page` object.
+ */
+
+export function pageDefaults(): PageDefault {
+  return {
+    path: canonicalPath(),
+    referrer: document.referrer,
+    search: location.search,
+    title: document.title,
+    url: canonicalUrl(location.search),
+  }
+}
+
+function enrichPageContext(ctx: Context): Context {
+  const event = ctx.event
+  event.context = event.context || {}
+  let pageContext = pageDefaults()
+  const pageProps = event.properties ?? {}
+
+  Object.keys(pageContext).forEach((key) => {
+    if (pageProps[key]) {
+      pageContext[key] = pageProps[key]
+    }
+  })
+
+  if (event.context.page) {
+    pageContext = Object.assign({}, pageContext, event.context.page)
+  }
+
+  event.context = Object.assign({}, event.context, {
+    page: pageContext,
+  })
+
+  ctx.event = event
+
+  return ctx
+}
+
+export const pageEnrichment: Plugin = {
+  name: 'Page Enrichment',
+  version: '0.1.0',
+  isLoaded: () => true,
+  load: () => Promise.resolve(),
+  type: 'before',
+
+  page: (ctx) => {
+    ctx.event.properties = Object.assign(
+      {},
+      pageDefaults(),
+      ctx.event.properties
+    )
+
+    if (ctx.event.name) {
+      ctx.event.properties.name = ctx.event.name
+    }
+
+    return enrichPageContext(ctx)
+  },
+
+  alias: enrichPageContext,
+  track: enrichPageContext,
+  identify: enrichPageContext,
+  group: enrichPageContext,
+}