@segment/analytics-browser-actions-playerzero 1.0.0

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@segment/analytics-browser-actions-playerzero",
+  "version": "1.0.0",
+  "license": "MIT",
+  "main": "./dist/cjs",
+  "module": "./dist/esm",
+  "scripts": {
+    "build": "yarn build:esm && yarn build:cjs",
+    "build:cjs": "tsc --module commonjs --outDir ./dist/cjs",
+    "build:esm": "tsc --outDir ./dist/esm"
+  },
+  "typings": "./dist/esm",
+  "dependencies": {
+    "@segment/actions-core": "^3.71.0",
+    "@segment/browser-destination-runtime": "^1.0.0"
+  },
+  "peerDependencies": {
+    "@segment/analytics-next": "*"
+  }
+}

package/src/__tests__/index.test.ts

@@ -0,0 +1,18 @@
+import { Analytics, Context } from '@segment/analytics-next'
+import playerzero, { destination } from '../index'
+import { subscriptions, TEST_PROJECT_ID } from '../test-utils'
+
+test.skip('load PlayerZero', async () => {
+  const [event] = await playerzero({
+    projectId: TEST_PROJECT_ID,
+    subscriptions
+  })
+
+  jest.spyOn(destination, 'initialize')
+
+  await event.load(Context.system(), {} as Analytics)
+  expect(destination.initialize).toHaveBeenCalled()
+  expect(window.playerzero).toHaveProperty('track')
+  expect(window.playerzero).toHaveProperty('identify')
+  expect(window.playerzero).toHaveProperty('setUserVars')
+})

package/src/generated-types.ts

@@ -0,0 +1,8 @@
+// Generated file. DO NOT MODIFY IT BY HAND.
+
+export interface Settings {
+  /**
+   * The Project ID where you want to send data. You can find this ID on the [Project Data Collection](https://go.playerzero.app/setting/data) page.
+   */
+  projectId: string
+}

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

@@ -0,0 +1,78 @@
+import { Analytics, Context } from '@segment/analytics-next'
+import playerzero from '../../index'
+import { subscriptions, TEST_PROJECT_ID } from '../../test-utils'
+
+describe.skip('PlayerzeroWeb.identifyUser', () => {
+  it('should keep anonymous users', async () => {
+    const [_, identifyUser] = await playerzero({
+      projectId: TEST_PROJECT_ID,
+      subscriptions
+    })
+
+    await identifyUser.load(Context.system(), {} as Analytics)
+    const pzUserVars = jest.spyOn(window.playerzero, 'setUserVars')
+    const pzIdentify = jest.spyOn(window.playerzero, 'identify')
+
+    await identifyUser.identify?.(
+      new Context({
+        type: 'identify',
+        anonymousId: 'ghost',
+        traits: {
+          hello: 'world'
+        }
+      })
+    )
+
+    expect(pzUserVars).toHaveBeenCalled()
+    expect(pzIdentify).not.toHaveBeenCalled()
+    expect(pzUserVars).toHaveBeenCalledWith({
+      segmentAnonymousId: 'ghost',
+      hello: 'world'
+    })
+  })
+
+  it('should identify a user with id', async () => {
+    const [_, identifyUser] = await playerzero({
+      projectId: TEST_PROJECT_ID,
+      subscriptions
+    })
+    await identifyUser.load(Context.system(), {} as Analytics)
+    const pzIdentify = jest.spyOn(window.playerzero, 'identify')
+
+    await identifyUser.identify?.(
+      new Context({
+        type: 'identify',
+        userId: 'id'
+      })
+    )
+    expect(pzIdentify).toHaveBeenCalledWith('id', {})
+  })
+
+  it.skip('sets identity and traits', async () => {
+    const [_, identifyUser] = await playerzero({
+      projectId: TEST_PROJECT_ID,
+      subscriptions
+    })
+
+    await identifyUser.load(Context.system(), {} as Analytics)
+    const pzIdentify = jest.spyOn(window.playerzero, 'identify')
+
+    await identifyUser.identify?.(
+      new Context({
+        type: 'identify',
+        userId: 'id',
+        anonymousId: 'ghost',
+        traits: {
+          name: 'Joe',
+          email: 'billy@bob.com'
+        }
+      })
+    )
+
+    expect(pzIdentify).toHaveBeenCalledWith('id', {
+      name: 'Joe',
+      email: 'billy@bob.com',
+      segmentAnonymousId: 'ghost'
+    })
+  })
+})

package/src/identifyUser/generated-types.ts

@@ -0,0 +1,26 @@
+// Generated file. DO NOT MODIFY IT BY HAND.
+
+export interface Payload {
+  /**
+   * The user's id
+   */
+  userId?: string
+  /**
+   * The user's anonymous id
+   */
+  anonymousId?: string
+  /**
+   * The user's name
+   */
+  name?: string
+  /**
+   * The user's email
+   */
+  email?: string
+  /**
+   * The Segment traits to be included as metadata in PlayerZero
+   */
+  traits?: {
+    [k: string]: unknown
+  }
+}

package/src/identifyUser/index.ts

@@ -0,0 +1,96 @@
+import type { BrowserActionDefinition } from '@segment/browser-destination-runtime/types'
+import type { Settings } from '../generated-types'
+import { PlayerZero } from '../types'
+import type { Payload } from './generated-types'
+
+const action: BrowserActionDefinition<Settings, PlayerZero, Payload> = {
+  title: 'Identify User',
+  description: 'Sets the user identity',
+  platform: 'web',
+  defaultSubscription: 'type = "identify"',
+  fields: {
+    userId: {
+      type: 'string',
+      required: false,
+      description: "The user's id",
+      label: 'User ID',
+      default: {
+        '@path': '$.userId'
+      }
+    },
+    anonymousId: {
+      type: 'string',
+      required: false,
+      description: "The user's anonymous id",
+      label: 'Anonymous ID',
+      default: {
+        '@path': '$.anonymousId'
+      }
+    },
+    name: {
+      type: 'string',
+      required: false,
+      description: "The user's name",
+      label: 'Display Name',
+      default: {
+        '@path': '$.traits.name'
+      }
+    },
+    email: {
+      type: 'string',
+      required: false,
+      description: "The user's email",
+      label: 'Email',
+      default: {
+        '@path': '$.traits.email'
+      }
+    },
+    traits: {
+      type: 'object',
+      required: false,
+      description: 'The Segment traits to be included as metadata in PlayerZero',
+      label: 'Traits',
+      default: {
+        '@path': '$.traits'
+      }
+    }
+  },
+  perform: (playerzero, event) => {
+    let newTraits: Record<string, unknown> = {}
+
+    if (event.payload.traits) {
+      newTraits = Object.entries(event.payload.traits).reduce(
+        (acc, [key, value]) => ({
+          ...acc,
+          [cleanKey(key)]: value
+        }),
+        {}
+      )
+    }
+
+    if (event.payload.anonymousId) {
+      newTraits.segmentAnonymousId = event.payload.anonymousId
+    }
+
+    if (event.payload.userId) {
+      playerzero.identify(event.payload.userId, newTraits)
+    } else {
+      playerzero.setUserVars({
+        ...newTraits,
+        ...(event.payload.email !== undefined && { email: event.payload.email }),
+        ...(event.payload.name !== undefined && { name: event.payload.name })
+      })
+    }
+  }
+}
+
+/**
+ * Clean up variable name to be compatible with
+ *
+ * @param {string} key
+ */
+function cleanKey(key: string) {
+  return key.trim().toLowerCase().replace(' ', '_')
+}
+
+export default action

package/src/index.ts

@@ -0,0 +1,62 @@
+import { defaultValues } from '@segment/actions-core'
+import type { Settings } from './generated-types'
+import type { BrowserDestinationDefinition } from '@segment/browser-destination-runtime/types'
+import { browserDestination } from '@segment/browser-destination-runtime/shim'
+import { PlayerZero } from './types'
+
+import identifyUser from './identifyUser'
+
+import trackEvent from './trackEvent'
+
+declare global {
+  interface Window {
+    playerzero: PlayerZero
+  }
+}
+
+// Switch from unknown to the partner SDK client types
+export const destination: BrowserDestinationDefinition<Settings, PlayerZero> = {
+  name: 'PlayerZero Web',
+  slug: 'actions-playerzero-web',
+  mode: 'device',
+
+  settings: {
+    // Add any Segment destination settings required here
+    projectId: {
+      label: 'PlayerZero Project ID',
+      description:
+        'The Project ID where you want to send data. You can find this ID on the [Project Data Collection](https://go.playerzero.app/setting/data) page.',
+      type: 'string',
+      required: true
+    }
+  },
+
+  presets: [
+    {
+      name: 'Track Event',
+      subscribe: 'type = "track"',
+      partnerAction: 'trackEvent',
+      mapping: defaultValues(trackEvent.fields)
+    },
+    {
+      name: 'Identify User',
+      subscribe: 'type = "identify"',
+      partnerAction: 'identifyUser',
+      mapping: defaultValues(identifyUser.fields)
+    }
+  ],
+
+  initialize: async ({ settings }, deps) => {
+    await deps.loadScript(`https://go.playerzero.app/record/${settings.projectId}`)
+    // initialize client code here
+    await deps.resolveWhen(() => Object.prototype.hasOwnProperty.call(window, 'playerzero'), 250)
+    return window.playerzero
+  },
+
+  actions: {
+    trackEvent,
+    identifyUser
+  }
+}
+
+export default browserDestination(destination)

package/src/test-utils.ts

@@ -0,0 +1,43 @@
+import { Subscription } from '@segment/browser-destination-runtime/types'
+
+export const TEST_PROJECT_ID = '634947ab6e8b1d18374ed00c'
+
+export const subscriptions: Subscription[] = [
+  {
+    partnerAction: 'trackEvent',
+    name: 'Track Event',
+    enabled: true,
+    subscribe: 'type = "track"',
+    mapping: {
+      name: {
+        '@path': '$.name'
+      },
+      properties: {
+        '@path': '$.properties'
+      }
+    }
+  },
+  {
+    partnerAction: 'identifyUser',
+    name: 'Identify User',
+    enabled: true,
+    subscribe: 'type = "identify"',
+    mapping: {
+      anonymousId: {
+        '@path': '$.anonymousId'
+      },
+      userId: {
+        '@path': '$.userId'
+      },
+      name: {
+        '@path': '$.traits.name'
+      },
+      email: {
+        '@path': '$.traits.email'
+      },
+      traits: {
+        '@path': '$.traits'
+      }
+    }
+  }
+]

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

@@ -0,0 +1,33 @@
+import { Analytics, Context } from '@segment/analytics-next'
+import playerzero, { destination } from '../../index'
+import { subscriptions, TEST_PROJECT_ID } from '../../test-utils'
+
+describe('PlayerzeroWeb.trackEvent', () => {
+  it.skip('emits a PlayerZero track event', async () => {
+    const [event] = await playerzero({
+      projectId: TEST_PROJECT_ID,
+      subscriptions
+    })
+
+    await event.load(Context.system(), {} as Analytics)
+    jest.spyOn(destination.actions.trackEvent, 'perform')
+    const pz = jest.spyOn(window.playerzero, 'track')
+
+    const ctx = await event.track?.(
+      new Context({
+        type: 'track',
+        name: 'test event',
+        properties: {
+          hello: 'world'
+        }
+      })
+    )
+
+    expect(ctx).not.toBeUndefined()
+    expect(pz).toHaveBeenCalledWith('test event', {
+      hello: 'world'
+    })
+
+    expect(destination.actions.trackEvent.perform).toHaveBeenCalled()
+  })
+})

package/src/trackEvent/generated-types.ts

@@ -0,0 +1,14 @@
+// Generated file. DO NOT MODIFY IT BY HAND.
+
+export interface Payload {
+  /**
+   * The name of the event.
+   */
+  name: string
+  /**
+   * A JSON object containing more information about the event.
+   */
+  properties?: {
+    [k: string]: unknown
+  }
+}

package/src/trackEvent/index.ts

@@ -0,0 +1,36 @@
+import type { BrowserActionDefinition } from '@segment/browser-destination-runtime/types'
+import type { Settings } from '../generated-types'
+import { PlayerZero } from '../types'
+import type { Payload } from './generated-types'
+
+const action: BrowserActionDefinition<Settings, PlayerZero, Payload> = {
+  title: 'Track Event',
+  description: 'Track events',
+  platform: 'web',
+  defaultSubscription: 'type = "track"',
+  fields: {
+    name: {
+      description: 'The name of the event.',
+      label: 'Event name',
+      required: true,
+      type: 'string',
+      default: {
+        '@path': '$.event'
+      }
+    },
+    properties: {
+      description: 'A JSON object containing more information about the event.',
+      label: 'Properties',
+      required: false,
+      type: 'object',
+      default: {
+        '@path': '$.properties'
+      }
+    }
+  },
+  perform: (playerzero, event) => {
+    playerzero.track(event.payload.name, event.payload.properties)
+  }
+}
+
+export default action

package/src/types.ts

@@ -0,0 +1,5 @@
+export interface PlayerZero {
+  identify: (userId: string, metadata: Record<string, unknown>) => void
+  setUserVars: (metadata: Record<string, unknown>) => void
+  track: (event: string, metadata?: Record<string, unknown>) => void
+}

package/tsconfig.json

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