utneque 1.0.0

package/packages/browser/src/core/query-string/__tests__/index.test.ts

@@ -0,0 +1,149 @@
+import { queryString } from '..'
+import { Analytics } from '../../analytics'
+
+let analytics: Analytics
+
+describe('queryString', () => {
+  beforeEach(() => {
+    analytics = new Analytics({
+      writeKey: 'abc',
+    })
+  })
+
+  describe('calls', () => {
+    describe('identify', () => {
+      it('if `ajs_uid` is present', async () => {
+        const spy = jest.spyOn(analytics, 'identify')
+        await queryString(analytics, '?ajs_uid=1234')
+        expect(spy).toHaveBeenCalledWith('1234', {})
+        spy.mockRestore()
+      })
+
+      it('accepts encoded emails as `ajs_uid` params', async () => {
+        const spy = jest.spyOn(analytics, 'identify')
+        await queryString(analytics, '?ajs_uid=user%40example.org')
+        expect(spy).toHaveBeenCalledWith('user@example.org', {})
+        spy.mockRestore()
+      })
+
+      it('applies traits if `ajs_trait_` is present', async () => {
+        const spy = jest.spyOn(analytics, 'identify')
+        await queryString(analytics, '?ajs_uid=1234&ajs_trait_address=123 St')
+        expect(spy).toHaveBeenCalledWith('1234', { address: '123 St' })
+        spy.mockRestore()
+      })
+
+      it('applies multiple traits if `ajs_trait_` is declared more than once', async () => {
+        const spy = jest.spyOn(analytics, 'identify')
+        await queryString(
+          analytics,
+          '?ajs_uid=1234&ajs_trait_address=123 St&ajs_trait_city=Vancouver'
+        )
+        expect(spy).toHaveBeenCalledWith('1234', {
+          address: '123 St',
+          city: 'Vancouver',
+        })
+        spy.mockRestore()
+      })
+
+      it('only considers one `ajs_uid` received as parameter', async () => {
+        const spy = jest.spyOn(analytics, 'identify')
+        await queryString(
+          analytics,
+          '?ajs_uid=1234&ajs_trait_address=123 St&ajs_trait_address=908 St'
+        )
+        expect(spy).toHaveBeenCalledWith('1234', { address: '908 St' })
+        spy.mockRestore()
+      })
+    })
+
+    describe('track', () => {
+      it('calls track if `ajs_event` is present', async () => {
+        const spy = jest.spyOn(analytics, 'track')
+        await queryString(analytics, '?ajs_event=Button Clicked')
+        expect(spy).toHaveBeenCalledWith('Button Clicked', {})
+        spy.mockRestore()
+      })
+
+      it('applies props if `ajs_prop_` is present', async () => {
+        const spy = jest.spyOn(analytics, 'track')
+        await queryString(
+          analytics,
+          '?ajs_event=Button Clicked&ajs_prop_location=Home Page'
+        )
+        expect(spy).toHaveBeenCalledWith('Button Clicked', {
+          location: 'Home Page',
+        })
+        spy.mockRestore()
+      })
+
+      it('applies multiple props if `ajs_prop_` is declared more than once', async () => {
+        const spy = jest.spyOn(analytics, 'track')
+        await queryString(
+          analytics,
+          '?ajs_event=Button Clicked&ajs_prop_location=Home Page&ajs_prop_team=Instrumentation'
+        )
+        expect(spy).toHaveBeenCalledWith('Button Clicked', {
+          location: 'Home Page',
+          team: 'Instrumentation',
+        })
+        spy.mockRestore()
+      })
+
+      it('only considers the first `ajs_event` received as parameter', async () => {
+        const spy = jest.spyOn(analytics, 'track')
+        await queryString(
+          analytics,
+          '?ajs_event=Button Clicked&ajs_prop_location=Home Page&ajs_prop_location=Teams Page'
+        )
+        expect(spy).toHaveBeenCalledWith('Button Clicked', {
+          location: 'Teams Page',
+        })
+        spy.mockRestore()
+      })
+    })
+
+    describe('setAnonymousId', () => {
+      it('if `ajs_aid` is present', async () => {
+        const spy = jest.spyOn(analytics, 'setAnonymousId')
+        await queryString(analytics, '?ajs_aid=immaghost')
+        expect(spy).toHaveBeenCalledWith('immaghost')
+        spy.mockRestore()
+      })
+
+      it('only considers the first aid received as parameter', async () => {
+        const spy = jest.spyOn(analytics, 'setAnonymousId')
+        await queryString(analytics, '?ajs_aid=imbatman&ajs_aid=bruce')
+        expect(spy).toHaveBeenCalledWith('bruce')
+        spy.mockRestore()
+      })
+    })
+
+    describe('setting anonymous id when making track and identify calls', () => {
+      it('updates the anonymous ids before track calls are made', async () => {
+        const dispatchSpy = jest.spyOn(analytics as any, '_dispatch')
+        await queryString(analytics, '?ajs_event=event&ajs_aid=ariel')
+        expect(dispatchSpy).toHaveBeenCalledWith(
+          expect.objectContaining({
+            anonymousId: 'ariel',
+            event: 'event',
+          }),
+          undefined
+        )
+        dispatchSpy.mockRestore()
+      })
+      it('updates the anonymous ids before identify calls are made', async () => {
+        const dispatchSpy = jest.spyOn(analytics as any, '_dispatch')
+        await queryString(analytics, '?ajs_uid=1234&ajs_aid=ariel')
+        expect(dispatchSpy).toHaveBeenCalledWith(
+          expect.objectContaining({
+            anonymousId: 'ariel',
+            userId: '1234',
+          }),
+          undefined
+        )
+        dispatchSpy.mockRestore()
+      })
+    })
+  })
+})

package/packages/browser/src/core/query-string/__tests__/pickPrefix.test.ts

@@ -0,0 +1,31 @@
+import { pickPrefix } from '../pickPrefix'
+
+describe('pickPrefix', () => {
+  it('strips a single prefix to creates an object', () => {
+    const traits = pickPrefix('ajs_traits_', {
+      ajs_traits_address: '12-123 St.',
+    })
+
+    const output = {
+      address: '12-123 St.',
+    }
+
+    expect(traits).toEqual(output)
+  })
+
+  it('stripts multiple prefixes to create an object', () => {
+    const traits = pickPrefix('ajs_traits_', {
+      ajs_traits_address: '12-123 St.',
+      ajs_traits_city: 'Vancouver',
+      ajs_traits_province: 'BC',
+    })
+
+    const output = {
+      address: '12-123 St.',
+      city: 'Vancouver',
+      province: 'BC',
+    }
+
+    expect(traits).toEqual(output)
+  })
+})

package/packages/browser/src/core/query-string/__tests__/useQueryString.test.ts

@@ -0,0 +1,60 @@
+import unfetch from 'unfetch'
+import { HtEventsBrowser } from '../../..'
+import { createSuccess } from '../../../test-helpers/factories'
+
+jest.mock('unfetch')
+jest
+  .mocked(unfetch)
+  .mockImplementation(() => createSuccess({ integrations: {} }))
+
+// @ts-ignore
+delete window.location
+// @ts-ignore
+window.location = new URL(
+  'https://www.example.com?ajs_aid=873832VB&ajs_uid=xcvn7568'
+)
+
+describe('useQueryString configuration option', () => {
+  it('ignores aid and uid from query string when disabled', async () => {
+    const [analyticsAlt] = await HtEventsBrowser.load(
+      { writeKey: 'abc' },
+      {
+        useQueryString: false,
+      }
+    )
+
+    // not acknowledge the aid provided in the query params, let ajs generate one
+    expect(analyticsAlt.user().anonymousId()).not.toBe('873832VB')
+    expect(analyticsAlt.user().id()).toBe(null)
+  })
+
+  it('ignores uid when it doesnt match the required pattern', async () => {
+    const [analyticsAlt] = await HtEventsBrowser.load(
+      { writeKey: 'abc' },
+      {
+        useQueryString: {
+          uid: /[A-Z]{6}/,
+        },
+      }
+    )
+
+    // no constraint was set for aid therefore accepted
+    expect(analyticsAlt.user().anonymousId()).toBe('873832VB')
+    expect(analyticsAlt.user().id()).toBe(null)
+  })
+
+  it('accepts both aid and uid from query string when they match the required pattern', async () => {
+    const [analyticsAlt] = await HtEventsBrowser.load(
+      { writeKey: 'abc' },
+      {
+        useQueryString: {
+          aid: /\d{6}[A-Z]{2}/,
+          uid: /[a-z]{4}\d{4}/,
+        },
+      }
+    )
+
+    expect(analyticsAlt.user().anonymousId()).toBe('873832VB')
+    expect(analyticsAlt.user().id()).toBe('xcvn7568')
+  })
+})

package/packages/browser/src/core/query-string/gracefulDecodeURIComponent.ts

@@ -0,0 +1,16 @@
+/**
+ * Tries to gets the unencoded version of an encoded component of a
+ * Uniform Resource Identifier (URI). If input string is malformed,
+ * returns it back as-is.
+ *
+ * Note: All occurences of the `+` character become ` ` (spaces).
+ **/
+export function gracefulDecodeURIComponent(
+  encodedURIComponent: string
+): string {
+  try {
+    return decodeURIComponent(encodedURIComponent.replace(/\+/g, ' '))
+  } catch {
+    return encodedURIComponent
+  }
+}

package/packages/browser/src/core/query-string/index.ts

@@ -0,0 +1,64 @@
+import { pickPrefix } from './pickPrefix'
+import { gracefulDecodeURIComponent } from './gracefulDecodeURIComponent'
+import { Analytics } from '../analytics'
+import { Context } from '../context'
+import { isPlainObject } from '@ht-sdks/events-sdk-js-core'
+
+export interface QueryStringParams {
+  [key: string]: string | null
+}
+
+export function queryString(
+  analytics: Analytics,
+  query: string
+): Promise<Context[]> {
+  const a = document.createElement('a')
+  a.href = query
+  const parsed = a.search.slice(1)
+  const params = parsed.split('&').reduce((acc: QueryStringParams, str) => {
+    const [k, v] = str.split('=')
+    acc[k] = gracefulDecodeURIComponent(v)
+    return acc
+  }, {})
+
+  const calls = []
+
+  const { ajs_uid, ajs_event, ajs_aid } = params
+  const { aid: aidPattern = /.+/, uid: uidPattern = /.+/ } = isPlainObject(
+    analytics.options.useQueryString
+  )
+    ? analytics.options.useQueryString
+    : {}
+
+  if (ajs_aid) {
+    const anonId = Array.isArray(params.ajs_aid)
+      ? params.ajs_aid[0]
+      : params.ajs_aid
+
+    if (aidPattern.test(anonId)) {
+      analytics.setAnonymousId(anonId)
+    }
+  }
+
+  if (ajs_uid) {
+    const uid = Array.isArray(params.ajs_uid)
+      ? params.ajs_uid[0]
+      : params.ajs_uid
+
+    if (uidPattern.test(uid)) {
+      const traits = pickPrefix('ajs_trait_', params)
+
+      calls.push(analytics.identify(uid, traits))
+    }
+  }
+
+  if (ajs_event) {
+    const event = Array.isArray(params.ajs_event)
+      ? params.ajs_event[0]
+      : params.ajs_event
+    const props = pickPrefix('ajs_prop_', params)
+    calls.push(analytics.track(event, props))
+  }
+
+  return Promise.all(calls)
+}

package/packages/browser/src/core/query-string/pickPrefix.ts

@@ -0,0 +1,20 @@
+import { QueryStringParams } from '.'
+
+/**
+ * Returns an object containing only the properties prefixed by the input
+ * string.
+ * Ex: prefix('ajs_traits_', { ajs_traits_address: '123 St' })
+ * will return { address: '123 St' }
+ **/
+export function pickPrefix(
+  prefix: string,
+  object: QueryStringParams
+): QueryStringParams {
+  return Object.keys(object).reduce((acc: QueryStringParams, key: string) => {
+    if (key.startsWith(prefix)) {
+      const field = key.substr(prefix.length)
+      acc[field] = object[key]!
+    }
+    return acc
+  }, {})
+}

package/packages/browser/src/core/queue/__tests__/event-queue.test.ts

@@ -0,0 +1,82 @@
+import { Analytics } from '../../analytics'
+import { pWhile } from '../../../lib/p-while'
+import { Context } from '../../context'
+import { Plugin } from '../../plugin'
+import { EventQueue } from '../event-queue'
+import { ActionDestination } from '../../../plugins/remote-loader'
+
+async function flushAll(eq: EventQueue): Promise<Context[]> {
+  const flushSpy = jest.spyOn(eq, 'flush')
+  await pWhile(
+    () => eq.queue.length > 0,
+    async () => {
+      return new Promise((r) => setTimeout(r, 0))
+    }
+  )
+  const results = flushSpy.mock.results.map((r) => r.value)
+  flushSpy.mockClear()
+
+  const flushed = await Promise.all(results)
+  return flushed.reduce((prev, cur) => {
+    return prev.concat(cur)
+  }, [])
+}
+
+const testPlugin: Plugin = {
+  name: 'test',
+  type: 'before',
+  version: '0.1.0',
+  load: () => Promise.resolve(),
+  isLoaded: () => true,
+}
+
+const ajs = {} as Analytics
+
+/**
+ * This test file only contains event-queue tests that _are_ specific to this package.
+ * You should prefer to write tests in packages/core
+ */
+const hightouchio = {
+  ...testPlugin,
+  name: 'Hightouch.io',
+  type: 'after' as const,
+  track: (ctx: Context): Promise<Context> | Context => {
+    return Promise.resolve(ctx)
+  },
+}
+
+describe('alternative names', () => {
+  test('delivers to action destinations using alternative names', async () => {
+    const eq = new EventQueue(`writeKey:event-queue`)
+    const fullstory = new ActionDestination('fullstory', testPlugin) // TODO: This should be re-written as higher level integration test.
+    fullstory.alternativeNames.push('fullstory trackEvent')
+    fullstory.type = 'destination'
+
+    jest.spyOn(fullstory, 'track')
+    jest.spyOn(hightouchio, 'track')
+
+    const evt = {
+      type: 'track' as const,
+      integrations: {
+        All: false,
+        'fullstory trackEvent': true,
+        'Hightouch.io': {},
+      },
+    }
+
+    const ctx = new Context(evt)
+
+    await eq.register(Context.system(), fullstory, ajs)
+    await eq.register(Context.system(), hightouchio, ajs)
+
+    void eq.dispatch(ctx)
+
+    expect(eq.queue.length).toBe(1)
+    const flushed = await flushAll(eq)
+
+    expect(flushed).toEqual([ctx])
+
+    expect(fullstory.track).toHaveBeenCalled()
+    expect(hightouchio.track).toHaveBeenCalled()
+  })
+})

package/packages/browser/src/core/queue/event-queue.ts

@@ -0,0 +1,22 @@
+import { PriorityQueue } from '../../lib/priority-queue'
+import { PersistedPriorityQueue } from '../../lib/priority-queue/persisted'
+import { Context } from '../context'
+import { AnyBrowserPlugin } from '../plugin'
+import { CoreEventQueue } from '@ht-sdks/events-sdk-js-core'
+import { isOffline } from '../connection'
+
+export class EventQueue extends CoreEventQueue<Context, AnyBrowserPlugin> {
+  constructor(name: string)
+  constructor(priorityQueue: PriorityQueue<Context>)
+  constructor(nameOrQueue: string | PriorityQueue<Context>) {
+    super(
+      typeof nameOrQueue === 'string'
+        ? new PersistedPriorityQueue(4, nameOrQueue)
+        : nameOrQueue
+    )
+  }
+  async flush(): Promise<Context[]> {
+    if (isOffline()) return []
+    return super.flush()
+  }
+}

package/packages/browser/src/core/session/__tests__/index.test.ts

@@ -0,0 +1,41 @@
+import {
+  hasSessionExpired,
+  isManualSessionIdValid,
+  updateSessionExpiration,
+} from '..'
+
+describe('()', () => {
+  it('hasSessionExpired', () => {
+    const past = Date.now() - 10000
+    expect(hasSessionExpired(past)).toEqual(true)
+    const future = Date.now() + 10000
+    expect(hasSessionExpired(future)).toEqual(false)
+  })
+
+  it('isManualSessionIdValid', () => {
+    expect(isManualSessionIdValid(-100)).toBe(false)
+    expect(isManualSessionIdValid(100)).toBe(false)
+    expect(isManualSessionIdValid()).toBe(false)
+    expect(isManualSessionIdValid(Date.now())).toBe(true)
+  })
+
+  it('updateSessionExpiration', () => {
+    expect(updateSessionExpiration({})).toEqual({ sessionStart: false })
+    expect(updateSessionExpiration({ sessionStart: true })).toEqual({
+      sessionStart: false,
+    })
+    expect(
+      updateSessionExpiration({
+        autoTrack: true,
+        expiresAt: 10,
+        timeout: 15,
+        sessionStart: false,
+      })
+    ).toEqual({
+      autoTrack: true,
+      expiresAt: 25,
+      timeout: 15,
+      sessionStart: false,
+    })
+  })
+})

package/packages/browser/src/core/session/index.ts

@@ -0,0 +1,107 @@
+// https://github.com/rudderlabs/rudder-sdk-js/blob/3a818accd24e6b3667c75a6b60fb12aba36bdf7e/packages/analytics-js/LICENSE
+// MIT License
+
+// Copyright (c) 2021 RudderStack
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+export type SessionInfo = {
+  autoTrack?: boolean
+  manualTrack?: boolean
+  timeout?: number
+  expiresAt?: number
+  id?: number
+  sessionStart?: boolean
+}
+
+export type SessionContext = {
+  sessionId?: number
+  sessionStart?: boolean
+}
+
+/**
+ * A function to validate current session and return true/false depending on that
+ * @returns boolean
+ */
+export const hasSessionExpired = (expiresAt: number): boolean => {
+  const timestamp = Date.now()
+  return Boolean(timestamp > expiresAt)
+}
+
+const generateSessionId = (): number => Date.now()
+
+export const isManualSessionIdValid = (sessionId?: number): boolean => {
+  if (
+    !sessionId ||
+    sessionId.toString().startsWith('-') ||
+    sessionId.toString().length < 10
+  ) {
+    return false
+  }
+  return true
+}
+
+const MIN_SESSION_TIMEOUT_MS = 10 * 1000 // 10 seconds
+const DEFAULT_SESSION_TIMEOUT_MS = 30 * 60 * 1000 // 30 minutes
+
+/**
+ * A function to generate new auto tracking session
+ * @param sessionTimeout current timestamp
+ * @returns SessionInfo
+ */
+export const generateAutoTrackingSession = (
+  sessionTimeout?: number
+): SessionInfo => {
+  const timestamp = Date.now()
+  const timeout: number = sessionTimeout || DEFAULT_SESSION_TIMEOUT_MS
+  if (timeout < MIN_SESSION_TIMEOUT_MS) {
+    console.warn('Session timeouts of less than 10 seconds are not recommended')
+  }
+  return {
+    id: timestamp, // set the current timestamp
+    expiresAt: timestamp + timeout, // set the expiry time of the session
+    timeout,
+    sessionStart: true,
+    autoTrack: true,
+  }
+}
+
+/**
+ * A function to generate new manual tracking session
+ * @param id Provided sessionId
+ * @returns SessionInfo
+ */
+export const generateManualTrackingSession = (id?: number): SessionInfo => {
+  const sessionId: number = isManualSessionIdValid(id)
+    ? (id as number)
+    : generateSessionId()
+  return {
+    id: sessionId,
+    sessionStart: true,
+    manualTrack: true,
+  }
+}
+
+export const updateSessionExpiration = (session: SessionInfo): SessionInfo => {
+  session.sessionStart = false
+  if (session.autoTrack) {
+    session.expiresAt = session.expiresAt! + session.timeout!
+  }
+  return session
+}

package/packages/browser/src/core/stats/__tests__/index.test.ts

@@ -0,0 +1,15 @@
+import { RemoteMetrics } from '../remote-metrics'
+import { Stats } from '..'
+
+const spy = jest.spyOn(RemoteMetrics.prototype, 'increment')
+
+describe(Stats, () => {
+  test('forwards increments to remote metrics endpoint', () => {
+    Stats.initRemoteMetrics()
+
+    const stats = new Stats()
+    stats.increment('banana', 1, ['phone:1'])
+
+    expect(spy).toHaveBeenCalledWith('banana', ['phone:1'])
+  })
+})