utneque 1.0.0

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

@@ -0,0 +1,44 @@
+import type { Plugin } from '../../core/plugin'
+import type { Context } from '../../core/context'
+import {
+  assertUserIdentity,
+  isPlainObject,
+  ValidationError,
+  assertEventExists,
+  assertEventType,
+  assertTrackEventName,
+} from '@ht-sdks/events-sdk-js-core'
+
+function validate(ctx: Context): Context {
+  const event = ctx.event
+  assertEventExists(event)
+  assertEventType(event)
+
+  if (event.type === 'track') {
+    assertTrackEventName(event)
+  }
+
+  const props = event.properties ?? event.traits
+  if (event.type !== 'alias' && !isPlainObject(props)) {
+    throw new ValidationError('.properties', 'is not an object')
+  }
+
+  assertUserIdentity(event)
+  return ctx
+}
+
+export const validation: Plugin = {
+  name: 'Event Validation',
+  type: 'before',
+  version: '1.0.0',
+
+  isLoaded: () => true,
+  load: () => Promise.resolve(),
+
+  track: validate,
+  identify: validate,
+  page: validate,
+  alias: validate,
+  group: validate,
+  screen: validate,
+}

package/packages/browser/src/test-helpers/browser-storage.ts

@@ -0,0 +1,75 @@
+import cookie from 'js-cookie'
+
+const ajsCookieNames = [
+  'htjs_user_id',
+  'htjs_anonymous_id',
+  'htjs_group_id',
+] as const
+const ajsLocalStorageKeys = [
+  'htjs_user_traits',
+  'htjs_group_properties',
+] as const
+
+export const getAjsBrowserStorage = () => {
+  return getBrowserStorage({
+    cookieNames: ajsCookieNames,
+    localStorageKeys: ajsLocalStorageKeys,
+  })
+}
+
+export const getAnonId = () => getAjsBrowserStorage().htjs_anonymous_id
+
+export const clearAjsBrowserStorage = () => {
+  return clearBrowserStorage({
+    cookieNames: ajsCookieNames,
+    localStorageKeys: ajsLocalStorageKeys,
+  })
+}
+
+export function getBrowserStorage<
+  CookieNames extends string,
+  LSKeys extends string
+>({
+  cookieNames,
+  localStorageKeys,
+}: {
+  cookieNames: readonly CookieNames[]
+  localStorageKeys: readonly LSKeys[]
+}): Record<CookieNames | LSKeys, string | {}> {
+  const result = {} as ReturnType<typeof getBrowserStorage>
+
+  const cookies = cookie.get()
+  cookieNames.forEach((name) => {
+    if (name in cookies) {
+      result[name] = cookies[name]
+    }
+  })
+
+  localStorageKeys.forEach((key) => {
+    const value = localStorage.getItem(key)
+    if (value !== null && typeof value !== 'undefined') {
+      result[key] = JSON.parse(value)
+    }
+  })
+
+  return result
+}
+
+export function clearBrowserStorage({
+  cookieNames,
+  localStorageKeys, // if no keys are passed, the entire thing is cleared
+}: {
+  cookieNames: string[] | readonly string[]
+  localStorageKeys?: string[] | readonly string[]
+}) {
+  cookieNames.forEach((name) => {
+    cookie.remove(name)
+  })
+  if (!localStorageKeys) {
+    localStorage.clear()
+  } else {
+    localStorageKeys.forEach((key) => {
+      localStorage.removeItem(key)
+    })
+  }
+}

package/packages/browser/src/test-helpers/factories.ts

@@ -0,0 +1,18 @@
+export const createSuccess = (body: any, overrides: Partial<Response> = {}) => {
+  return Promise.resolve({
+    json: () => Promise.resolve(body),
+    ok: true,
+    status: 200,
+    statusText: 'OK',
+    ...overrides,
+  }) as Promise<Response>
+}
+
+export const createError = (overrides: Partial<Response> = {}) => {
+  return Promise.resolve({
+    ok: false,
+    status: 404,
+    statusText: 'Not Found',
+    ...overrides,
+  }) as Promise<Response>
+}

package/packages/browser/src/test-helpers/fetch-parse.ts

@@ -0,0 +1,8 @@
+export type FetchCall = [input: RequestInfo, init?: RequestInit | undefined]
+
+export const parseFetchCall = ([url, request]: FetchCall) => ({
+  url,
+  method: request?.method,
+  headers: request?.headers,
+  body: request?.body ? JSON.parse(request.body as any) : undefined,
+})

package/packages/browser/src/test-helpers/fixtures/cdn-settings.ts

@@ -0,0 +1,301 @@
+import { HtEventsBrowserSettings } from '../..'
+import { mockIntegrationName } from './classic-destination'
+
+type CDNSettings = NonNullable<HtEventsBrowserSettings['cdnSettings']>
+
+export const cdnSettingsKitchenSink: CDNSettings = {
+  integrations: {
+    [mockIntegrationName]: {},
+    'Customer.io': {
+      siteId: 'abc123foofixture', // overwritten
+      versionSettings: {
+        version: '2.2.3',
+        componentTypes: ['browser', 'server'],
+      },
+      type: 'browser',
+      bundlingStatus: 'bundled',
+    },
+    FullStory: {
+      debug: false,
+      org: 'se',
+      trackAllPages: false,
+      trackCategorizedPages: false,
+      trackNamedPages: false,
+      versionSettings: {
+        version: '3.0.1',
+        componentTypes: ['browser'],
+      },
+      type: 'browser',
+      bundlingStatus: 'bundled',
+    },
+    'Google Analytics': {
+      anonymizeIp: false,
+      classic: false,
+      contentGroupings: {},
+      dimensions: {},
+      domain: '',
+      doubleClick: false,
+      enableServerIdentify: false,
+      enhancedEcommerce: false,
+      enhancedLinkAttribution: false,
+      identifyCategory: '',
+      identifyEventName: '',
+      ignoredReferrers: [],
+      includeSearch: false,
+      metrics: {},
+      mobileTrackingId: '',
+      nameTracker: false,
+      nonInteraction: false,
+      optimize: '',
+      protocolMappings: {},
+      reportUncaughtExceptions: false,
+      resetCustomDimensionsOnPage: [],
+      sampleRate: 100,
+      sendUserId: false,
+      setAllMappedProps: true,
+      siteSpeedSampleRate: 1,
+      trackCategorizedPages: true,
+      trackNamedPages: true,
+      trackingId: 'UA-970334309-1',
+      useGoogleAmpClientId: false,
+      versionSettings: {
+        version: '2.18.5',
+        componentTypes: ['browser', 'ios', 'android', 'server'],
+      },
+      type: 'browser',
+      bundlingStatus: 'unbundled',
+    },
+    'Hightouch.io': {
+      apiKey: 'D8frB7upBChqDN9PMWksNvZYDaKJIYo6',
+      unbundledIntegrations: ['Google Analytics'],
+      addBundledMetadata: true,
+      maybeBundledConfigIds: {
+        'Customer.io': ['60104dde8882b933c2006d1f'],
+        FullStory: ['6010547f5a1d4d46c418d68e'],
+      },
+      versionSettings: {
+        version: '4.4.7',
+        componentTypes: ['browser'],
+      },
+    },
+  },
+  plan: {
+    track: {
+      __default: {
+        enabled: true,
+        integrations: {},
+      },
+    },
+    identify: {
+      __default: {
+        enabled: true,
+      },
+      address: {
+        enabled: true,
+      },
+      avatar: {
+        enabled: true,
+      },
+      bs: {
+        enabled: true,
+      },
+      bsAdjective: {
+        enabled: true,
+      },
+      bsBuzz: {
+        enabled: true,
+      },
+      bsNoun: {
+        enabled: true,
+      },
+      catchPhrase: {
+        enabled: true,
+      },
+      catchPhraseAdjective: {
+        enabled: true,
+      },
+      catchPhraseDescriptor: {
+        enabled: true,
+      },
+      catchPhraseNoun: {
+        enabled: true,
+      },
+      color: {
+        enabled: true,
+      },
+      company: {
+        enabled: true,
+      },
+      companyName: {
+        enabled: true,
+      },
+      companySuffix: {
+        enabled: true,
+      },
+      custom: {
+        enabled: true,
+      },
+      department: {
+        enabled: true,
+      },
+      domainName: {
+        enabled: true,
+      },
+      domainSuffix: {
+        enabled: true,
+      },
+      domainWord: {
+        enabled: true,
+      },
+      email: {
+        enabled: true,
+      },
+      exampleEmail: {
+        enabled: true,
+      },
+      findName: {
+        enabled: true,
+      },
+      firstName: {
+        enabled: true,
+      },
+      gender: {
+        enabled: true,
+      },
+      id: {
+        enabled: true,
+      },
+      ip: {
+        enabled: true,
+      },
+      ipv6: {
+        enabled: true,
+      },
+      jobArea: {
+        enabled: true,
+      },
+      jobDescriptor: {
+        enabled: true,
+      },
+      jobTitle: {
+        enabled: true,
+      },
+      jobType: {
+        enabled: true,
+      },
+      lastName: {
+        enabled: true,
+      },
+      mac: {
+        enabled: true,
+      },
+      name: {
+        enabled: true,
+      },
+      person: {
+        enabled: true,
+      },
+      phone: {
+        enabled: true,
+      },
+      prefix: {
+        enabled: true,
+      },
+      price: {
+        enabled: true,
+      },
+      product: {
+        enabled: true,
+      },
+      productAdjective: {
+        enabled: true,
+      },
+      productDescription: {
+        enabled: true,
+      },
+      productMaterial: {
+        enabled: true,
+      },
+      productName: {
+        enabled: true,
+      },
+      protocol: {
+        enabled: true,
+      },
+      suffix: {
+        enabled: true,
+      },
+      suffixes: {
+        enabled: true,
+      },
+      title: {
+        enabled: true,
+      },
+      url: {
+        enabled: true,
+      },
+      userAgent: {
+        enabled: true,
+      },
+      userName: {
+        enabled: true,
+      },
+      username: {
+        enabled: true,
+      },
+      website: {
+        enabled: true,
+      },
+    },
+    group: {
+      __default: {
+        enabled: true,
+      },
+      coolKids: {
+        enabled: true,
+      },
+    },
+  },
+  middlewareSettings: {
+    routingRules: [
+      {
+        matchers: [
+          {
+            ir: '["and",["=","event",{"value":"munanyo"}],["and",["=","type",{"value":"track"}],["=","properties.referrer",{"value":"munyaaaanyo"}]]]',
+            type: 'fql',
+            config: {
+              expr: 'event = "munanyo" and type = "track" and properties.referrer = "munyaaaanyo"',
+            },
+          },
+        ],
+        scope: 'destinations',
+        target_type: 'workspace::project::destination::config',
+        transformers: [
+          [
+            {
+              type: 'drop_properties',
+              config: {
+                drop: {
+                  properties: ['url'],
+                },
+              },
+            },
+          ],
+        ],
+        destinationName: 'Google Analytics',
+      },
+    ],
+  },
+  enabledMiddleware: {},
+  metrics: {
+    sampleRate: 0.1,
+  },
+  legacyVideoPluginsEnabled: true,
+  remotePlugins: [],
+}
+
+export const cdnSettingsMinimal: CDNSettings = {
+  integrations: {
+    [mockIntegrationName]: {},
+  },
+}

package/packages/browser/src/test-helpers/fixtures/classic-destination.ts

@@ -0,0 +1,25 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+/**
+ * This is a classic destination, such as:
+ * https://github.com/segmentio/analytics.js-integrations/blob/master/integrations/appcues/lib/index.js
+ */
+
+const integration = require('@segment/analytics.js-integration')
+
+export const mockIntegrationName = 'Fake'
+export const Fake = integration(mockIntegrationName)
+
+Fake.prototype.initialize = function () {
+  this.load(this.ready)
+}
+
+Fake.prototype.loaded = function () {
+  return true
+}
+
+Fake.prototype.track = function () {}
+
+Fake.prototype.load = function (callback: Function) {
+  // this callback is important to actually initialize.
+  callback()
+}

package/packages/browser/src/test-helpers/fixtures/client-hints.ts

@@ -0,0 +1,28 @@
+import {
+  UADataValues,
+  UALowEntropyJSON,
+} from '../../lib/client-hints/interfaces'
+
+export const lowEntropyTestData: UALowEntropyJSON = {
+  brands: [
+    {
+      brand: 'Google Chrome',
+      version: '113',
+    },
+    {
+      brand: 'Chromium',
+      version: '113',
+    },
+    {
+      brand: 'Not-A.Brand',
+      version: '24',
+    },
+  ],
+  mobile: false,
+  platform: 'macOS',
+}
+
+export const highEntropyTestData: UADataValues = {
+  architecture: 'x86',
+  bitness: '64',
+}

package/packages/browser/src/test-helpers/fixtures/create-fetch-method.ts

@@ -0,0 +1,30 @@
+import { LegacySettings } from '../..'
+import { createSuccess } from '../factories'
+import { cdnSettingsMinimal } from './cdn-settings'
+
+export const createMockFetchImplementation = (
+  cdnSettings: Partial<LegacySettings> = cdnSettingsMinimal
+) => {
+  return (...[url, req]: Parameters<typeof fetch>) => {
+    const reqUrl = url.toString()
+    if (
+      !req ||
+      (req.method === 'get' && reqUrl.includes('cdn.hightouch-events.com'))
+    ) {
+      // GET https://cdn.hightouch-events.com/v1/projects/{writeKey}
+      return createSuccess({ ...cdnSettingsMinimal, ...cdnSettings })
+    }
+
+    if (
+      req?.method === 'post' &&
+      reqUrl.includes('us-east-1.hightouch-events.com')
+    ) {
+      // POST https://us-east-1.hightouch-events.com/v1/{event.type}
+      return createSuccess({ success: true }, { status: 201 })
+    }
+
+    throw new Error(
+      `no match found for request (url:${url}, req:${JSON.stringify(req)})`
+    )
+  }
+}

package/packages/browser/src/test-helpers/fixtures/index.ts

@@ -0,0 +1,4 @@
+export * from './page-context'
+export * from './create-fetch-method'
+export * from './classic-destination'
+export * from './cdn-settings'

package/packages/browser/src/test-helpers/fixtures/page-context.ts

@@ -0,0 +1,11 @@
+import {
+  BufferedPageContext,
+  getDefaultBufferedPageContext,
+  getDefaultPageContext,
+  PageContext,
+} from '../../core/page'
+
+export const getPageCtxFixture = (): PageContext => getDefaultPageContext()
+
+export const getBufferedPageCtxFixture = (): BufferedPageContext =>
+  getDefaultBufferedPageContext()

package/packages/browser/src/test-helpers/test-writekeys.ts

@@ -0,0 +1,5 @@
+// Writekeys that are used in different unit/integration tests. These writekeys
+// were created for the purpose of testing AJS and are not used for anything else.
+
+export const TEST_WRITEKEY = 'D8frB7upBChqDN9PMWksNvZYDaKJIYo6' // Test writekey
+export const AMPLITUDE_WRITEKEY = 'c56fd8ca27d0f9adfe8ad78d846dfcc8' // Test amplitude writekey

package/packages/browser/src/test-helpers/type-assertions.ts

@@ -0,0 +1,11 @@
+type IsAny<T> = unknown extends T ? (T extends {} ? T : never) : never
+type NotAny<T> = T extends IsAny<T> ? never : T
+type NotUnknown<T> = unknown extends T ? never : T
+
+type NotTopType<T> = NotAny<T> & NotUnknown<T>
+
+// this is not meant to be run, just for type tests
+export function assertNotAny<T>(_val: NotTopType<T>) {}
+
+// this is not meant to be run, just for type tests
+export function assertIs<T extends SomeType, SomeType = any>(_val: T) {}

package/packages/browser/src/tester/__fixtures__/hightouch-snippet.ts

@@ -0,0 +1,64 @@
+/* eslint-disable */
+
+export const snippet = (writeKey: string, load: boolean = true, extra = '') => `
+!(function () {
+  var htevents = (window.htevents = window.htevents || [])
+  if (!htevents.initialize)
+    if (htevents.invoked) window.console && console.error && console.error('Hightouch snippet included twice.')
+    else {
+      htevents.invoked = !0
+      htevents.methods = [
+        'screen',
+        'register',
+        'deregister',
+        'trackSubmit',
+        'trackClick',
+        'trackLink',
+        'trackForm',
+        'pageview',
+        'identify',
+        'reset',
+        'group',
+        'track',
+        'ready',
+        'alias',
+        'debug',
+        'page',
+        'once',
+        'off',
+        'on',
+        'addSourceMiddleware',
+        'addIntegrationMiddleware',
+        'setAnonymousId',
+        'addDestinationMiddleware',
+      ]
+      htevents.factory = function (e) {
+        return function () {
+          var t = Array.prototype.slice.call(arguments)
+          t.unshift(e)
+          htevents.push(t)
+          return htevents
+        }
+      }
+      for (var e = 0; e < htevents.methods.length; e++) {
+        var key = htevents.methods[e]
+        htevents[key] = htevents.factory(key)
+      }
+      htevents.load = function (key, e) {
+        var t = document.createElement('script')
+        t.type = 'text/javascript'
+        t.async = !0
+        t.src = 'https://cdn.foo.com/analytics.js/v1/' + key + '/analytics.min.js'
+        var n = document.getElementsByTagName('script')[0]
+        n.parentNode.insertBefore(t, n)
+        htevents._loadOptions = e
+      }
+      var smw1 = function ({}) {}
+      htevents.addSourceMiddleware(smw1);
+      htevents.SNIPPET_VERSION = '4.13.1'
+      ${load && `htevents.load('${writeKey}')`}
+      htevents.page()
+      ${extra}
+    }
+})()
+`

package/packages/browser/src/tester/__fixtures__/index.html

@@ -0,0 +1,8 @@
+<html>
+  <head>
+    <script src="../../../dist/umd/index.js" async></script>
+  </head>
+  <body>
+    🍻
+  </body>
+</html>

package/packages/browser/src/tester/ajs-perf.ts

@@ -0,0 +1,30 @@
+import playwright from 'playwright'
+import { setup, teardown } from 'jest-dev-server'
+
+// @ts-ignore
+import lighthouse from 'lighthouse/lighthouse-core'
+// @ts-ignore
+import reportGenerator from 'lighthouse/report/generator/report-generator'
+
+export function gatherLighthouseMetrics(
+  page: playwright.Page
+): Promise<unknown> {
+  return lighthouse(page.url(), {
+    port: 9222,
+    logLevel: 'error',
+  }).then(({ lhr }: { lhr: unknown }) => {
+    return JSON.parse(reportGenerator.generateReport(lhr, 'json') as string)
+  })
+}
+
+export async function globalSetup(): Promise<void> {
+  await setup({
+    command: `node src/tester/server.js --port=3001`,
+    launchTimeout: 5000,
+    port: 3001,
+  })
+}
+
+export async function globalTeardown(): Promise<void> {
+  await teardown()
+}