@segment/analytics-browser-hubble-web 1.1.0

package/src/track/__tests__/index.test.ts

@@ -0,0 +1,84 @@
+import { Analytics, Context } from '@segment/analytics-next'
+import hubbleDestination, { destination } from '../../index'
+import { Subscription } from '@segment/browser-destination-runtime/types'
+
+const subscriptions: Subscription[] = [
+  {
+    partnerAction: 'track',
+    name: 'Track event',
+    enabled: true,
+    subscribe: 'type = "track"',
+    mapping: {
+      event: {
+        '@path': '$.event'
+      },
+      attributes: {
+        '@path': '$.properties'
+      }
+    }
+  }
+]
+
+describe('track', () => {
+  beforeAll(() => {
+    jest.mock('@segment/browser-destination-runtime/load-script', () => ({
+      loadScript: (_src: any, _attributes: any) => {}
+    }))
+    jest.mock('@segment/browser-destination-runtime/resolve-when', () => ({
+      resolveWhen: (_fn: any, _timeout: any) => {}
+    }))
+  })
+
+  let track: any
+  const mockTrack: jest.Mock<any, any> = jest.fn()
+
+  beforeEach(async () => {
+    const [hubbleTrack] = await hubbleDestination({
+      id: 'testID',
+      subscriptions
+    })
+
+    track = hubbleTrack
+
+    jest.spyOn(destination, 'initialize').mockImplementation(() => {
+      const mockedWithTrack = {
+        id: 'testID',
+        initialized: true,
+        emitter: { setSource: jest.fn() },
+        track: mockTrack,
+        identify: jest.fn(),
+        setSource: jest.fn()
+      }
+      return Promise.resolve(mockedWithTrack)
+    })
+    await track.load(Context.system(), {} as Analytics)
+  })
+
+  test('it maps event parameters correctly to track function', async () => {
+    jest.spyOn(destination.actions.track, 'perform')
+
+    await track.track?.(
+      new Context({
+        type: 'track',
+        event: 'event-test',
+        properties: {
+          prop1: 'something',
+          prop2: 'another-thing'
+        }
+      })
+    )
+
+    expect(destination.actions.track.perform).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({
+        payload: {
+          event: 'event-test',
+          attributes: {
+            prop1: 'something',
+            prop2: 'another-thing'
+          }
+        }
+      })
+    )
+  })
+})

package/src/track/generated-types.ts

@@ -0,0 +1,22 @@
+// Generated file. DO NOT MODIFY IT BY HAND.
+
+export interface Payload {
+  /**
+   * Event to be tracked
+   */
+  event: string
+  /**
+   * Object containing the attributes (properties) of the event
+   */
+  attributes?: {
+    [k: string]: unknown
+  }
+  /**
+   * Unique identifer of the user
+   */
+  userId?: string
+  /**
+   * Anonymous identifier of the user
+   */
+  anonymousId?: string
+}

package/src/track/index.ts

@@ -0,0 +1,63 @@
+import type { BrowserActionDefinition } from '@segment/browser-destination-runtime/types'
+import { Hubble } from '../types'
+import type { Settings } from '../generated-types'
+import type { Payload } from './generated-types'
+
+// Change from unknown to the partner SDK types
+const action: BrowserActionDefinition<Settings, Hubble, Payload> = {
+  title: 'Track',
+  description: 'Track events to trigger Hubble surveys',
+  platform: 'web',
+  defaultSubscription: 'type = "track"',
+  fields: {
+    event: {
+      description: 'Event to be tracked',
+      label: 'Event',
+      required: true,
+      type: 'string',
+      default: {
+        '@path': '$.event'
+      }
+    },
+    attributes: {
+      description: 'Object containing the attributes (properties) of the event',
+      type: 'object',
+      required: false,
+      label: 'Event Attributes',
+      default: {
+        '@path': '$.properties'
+      }
+    },
+    userId: {
+      description: 'Unique identifer of the user',
+      type: 'string',
+      required: false,
+      label: 'User ID',
+      default: {
+        '@path': '$.userId'
+      }
+    },
+    anonymousId: {
+      description: 'Anonymous identifier of the user',
+      type: 'string',
+      required: false,
+      label: 'Anonymous ID',
+      default: {
+        '@path': '$.anonymousId'
+      }
+    }
+  },
+  perform: (hubble, event) => {
+    const payload = event.payload
+
+    hubble.track &&
+      hubble.track({
+        event: payload.event,
+        attributes: payload.attributes,
+        userId: payload.userId,
+        anonymousId: payload.anonymousId
+      })
+  }
+}
+
+export default action

package/src/types.ts

@@ -0,0 +1,10 @@
+export type Methods = {
+  track?: (...args: unknown[]) => unknown
+  identify?: (...args: unknown[]) => unknown
+}
+
+export type Hubble = {
+  id: string
+  initialized: boolean
+  setSource: (source: string) => void
+} & Methods

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.build.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "baseUrl": "."
+  },
+  "include": ["src"],
+  "exclude": ["dist", "**/__tests__"]
+}