@segment/analytics-browser-actions-fullsession 1.1.0

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

@@ -0,0 +1,315 @@
+import { Analytics, Context } from '@segment/analytics-next'
+import fullSessionDestination from '../../index'
+import { Subscription } from '@segment/browser-destination-runtime/types'
+
+// Mock the browser destination runtime functions
+jest.mock('@segment/browser-destination-runtime/load-script', () => ({
+  loadScript: (_src: any, _attributes: any) => Promise.resolve()
+}))
+
+jest.mock('@segment/browser-destination-runtime/resolve-when', () => ({
+  resolveWhen: (_fn: any, _timeout: any) => Promise.resolve()
+}))
+
+// Mock the fullsession package
+jest.mock('fullsession', () => ({
+  fullSessionTracker: {
+    initialize: jest.fn(),
+    identify: jest.fn(),
+    setSessionAttributes: jest.fn(),
+    event: jest.fn()
+  }
+}))
+
+const identifySubscription: Subscription = {
+  partnerAction: 'identifyUser',
+  name: 'Identify User',
+  enabled: true,
+  subscribe: 'type = "identify"',
+  mapping: {
+    userId: {
+      '@path': '$.userId'
+    },
+    anonymousId: {
+      '@path': '$.anonymousId'
+    },
+    traits: {
+      '@path': '$.traits'
+    }
+  }
+}
+
+describe('FullSession identifyUser action', () => {
+  const mockCustomerId = 'test-customer-id'
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    // Setup window.FUS mock if needed
+    if (typeof window !== 'undefined') {
+      // @ts-ignore
+      window.FUS = {}
+    }
+  })
+
+  test('should identify user with userId and basic traits', async () => {
+    const { fullSessionTracker } = await import('fullsession')
+
+    const [event] = await fullSessionDestination({
+      customerId: mockCustomerId,
+      subscriptions: [identifySubscription] as any
+    })
+
+    await event.load(Context.system(), {} as Analytics)
+
+    await event.identify?.(
+      new Context({
+        type: 'identify',
+        userId: 'user123',
+        anonymousId: 'anon123',
+        traits: {
+          name: 'John Doe',
+          email: 'john@example.com'
+        }
+      })
+    )
+
+    expect(fullSessionTracker.identify).toHaveBeenCalledWith('user123', {
+      name: 'John Doe',
+      email: 'john@example.com'
+    })
+
+    expect(fullSessionTracker.setSessionAttributes).toHaveBeenCalledWith({
+      segmentAnonymousId: 'anon123'
+    })
+  })
+
+  test('should identify user with userId and additional traits', async () => {
+    const { fullSessionTracker } = await import('fullsession')
+
+    const [event] = await fullSessionDestination({
+      customerId: mockCustomerId,
+      subscriptions: [identifySubscription] as any
+    })
+
+    await event.load(Context.system(), {} as Analytics)
+
+    await event.identify?.(
+      new Context({
+        type: 'identify',
+        userId: 'user123',
+        anonymousId: 'anon123',
+        traits: {
+          name: 'John Doe',
+          email: 'john@example.com',
+          company: 'Test Corp',
+          role: 'Developer',
+          age: 30
+        }
+      })
+    )
+
+    expect(fullSessionTracker.identify).toHaveBeenCalledWith('user123', {
+      name: 'John Doe',
+      email: 'john@example.com'
+    })
+
+    expect(fullSessionTracker.setSessionAttributes).toHaveBeenCalledWith({
+      company: 'Test Corp',
+      role: 'Developer',
+      age: 30,
+      segmentAnonymousId: 'anon123'
+    })
+  })
+
+  test('should identify user with anonymousId when userId is not present', async () => {
+    const { fullSessionTracker } = await import('fullsession')
+
+    const [event] = await fullSessionDestination({
+      customerId: mockCustomerId,
+      subscriptions: [identifySubscription] as any
+    })
+
+    await event.load(Context.system(), {} as Analytics)
+
+    await event.identify?.(
+      new Context({
+        type: 'identify',
+        anonymousId: 'anon123',
+        traits: {
+          name: 'Jane Doe',
+          email: 'jane@example.com',
+          company: 'Test Corp'
+        }
+      })
+    )
+
+    expect(fullSessionTracker.identify).toHaveBeenCalledWith('anon123', {
+      name: 'Jane Doe',
+      email: 'jane@example.com'
+    })
+
+    expect(fullSessionTracker.setSessionAttributes).toHaveBeenCalledWith({
+      company: 'Test Corp',
+      segmentAnonymousId: 'anon123'
+    })
+  })
+
+  test('should prefer userId over anonymousId when both are present', async () => {
+    const { fullSessionTracker } = await import('fullsession')
+
+    const [event] = await fullSessionDestination({
+      customerId: mockCustomerId,
+      subscriptions: [identifySubscription] as any
+    })
+
+    await event.load(Context.system(), {} as Analytics)
+
+    await event.identify?.(
+      new Context({
+        type: 'identify',
+        userId: 'user123',
+        anonymousId: 'anon123',
+        traits: {
+          name: 'John Doe',
+          email: 'john@example.com',
+          company: 'Test Corp'
+        }
+      })
+    )
+
+    expect(fullSessionTracker.identify).toHaveBeenCalledWith('user123', {
+      name: 'John Doe',
+      email: 'john@example.com'
+    })
+
+    expect(fullSessionTracker.setSessionAttributes).toHaveBeenCalledWith({
+      company: 'Test Corp',
+      segmentAnonymousId: 'anon123'
+    })
+  })
+
+  test('should handle empty or missing name and email', async () => {
+    const { fullSessionTracker } = await import('fullsession')
+
+    const [event] = await fullSessionDestination({
+      customerId: mockCustomerId,
+      subscriptions: [identifySubscription] as any
+    })
+
+    await event.load(Context.system(), {} as Analytics)
+
+    await event.identify?.(
+      new Context({
+        type: 'identify',
+        userId: 'user123',
+        anonymousId: 'anon123',
+        traits: {
+          company: 'Test Corp'
+        }
+      })
+    )
+
+    expect(fullSessionTracker.identify).toHaveBeenCalledWith('user123', {
+      name: '',
+      email: ''
+    })
+
+    expect(fullSessionTracker.setSessionAttributes).toHaveBeenCalledWith({
+      company: 'Test Corp',
+      segmentAnonymousId: 'anon123'
+    })
+  })
+
+  test('should call setSessionAttributes with empty object when only name and email are present', async () => {
+    const { fullSessionTracker } = await import('fullsession')
+
+    const [event] = await fullSessionDestination({
+      customerId: mockCustomerId,
+      subscriptions: [identifySubscription] as any
+    })
+
+    await event.load(Context.system(), {} as Analytics)
+
+    await event.identify?.(
+      new Context({
+        type: 'identify',
+        userId: 'user123',
+        anonymousId: 'anon123',
+        traits: {
+          name: 'John Doe',
+          email: 'john@example.com'
+        }
+      })
+    )
+
+    expect(fullSessionTracker.identify).toHaveBeenCalledWith('user123', {
+      name: 'John Doe',
+      email: 'john@example.com'
+    })
+
+    expect(fullSessionTracker.setSessionAttributes).toHaveBeenCalledWith({
+      segmentAnonymousId: 'anon123'
+    })
+  })
+
+  test('should handle case without anonymousId', async () => {
+    const { fullSessionTracker } = await import('fullsession')
+
+    const [event] = await fullSessionDestination({
+      customerId: mockCustomerId,
+      subscriptions: [identifySubscription] as any
+    })
+
+    await event.load(Context.system(), {} as Analytics)
+
+    await event.identify?.(
+      new Context({
+        type: 'identify',
+        userId: 'user123',
+        traits: {
+          name: 'John Doe',
+          email: 'john@example.com',
+          company: 'Test Corp'
+        }
+      })
+    )
+
+    expect(fullSessionTracker.identify).toHaveBeenCalledWith('user123', {
+      name: 'John Doe',
+      email: 'john@example.com'
+    })
+
+    expect(fullSessionTracker.setSessionAttributes).toHaveBeenCalledWith({
+      company: 'Test Corp'
+    })
+  })
+
+  test('should handle null or undefined traits', async () => {
+    const { fullSessionTracker } = await import('fullsession')
+
+    const [event] = await fullSessionDestination({
+      customerId: mockCustomerId,
+      subscriptions: [identifySubscription] as any
+    })
+
+    await event.load(Context.system(), {} as Analytics)
+
+    await event.identify?.(
+      new Context({
+        type: 'identify',
+        userId: 'user123',
+        anonymousId: 'anon123'
+        // traits is undefined
+      })
+    )
+
+    expect(fullSessionTracker.identify).toHaveBeenCalledWith('user123', {
+      name: '',
+      email: ''
+    })
+
+    expect(fullSessionTracker.setSessionAttributes).toHaveBeenCalledWith({
+      segmentAnonymousId: 'anon123'
+    })
+  })
+})

package/src/identifyUser/generated-types.ts

@@ -0,0 +1,18 @@
+// Generated file. DO NOT MODIFY IT BY HAND.
+
+export interface Payload {
+  /**
+   * The user's unique identifier.
+   */
+  userId?: string
+  /**
+   * The user's anonymous identifier when no user ID is available.
+   */
+  anonymousId?: string
+  /**
+   * User traits and properties to be sent to FullSession.
+   */
+  traits?: {
+    [k: string]: unknown
+  }
+}

package/src/identifyUser/index.ts

@@ -0,0 +1,66 @@
+import type { BrowserActionDefinition } from '@segment/browser-destination-runtime/types'
+import type { Settings } from '../generated-types'
+import type { Payload } from './generated-types'
+import { FUS } from '../types'
+
+const action: BrowserActionDefinition<Settings, FUS, Payload> = {
+  title: 'Identify User',
+  description: 'Identify users and set their properties in FullSession.',
+  platform: 'web',
+  defaultSubscription: 'type = "identify"',
+  fields: {
+    userId: {
+      type: 'string',
+      required: false,
+      description: "The user's unique identifier.",
+      label: 'User ID',
+      default: {
+        '@path': '$.userId'
+      }
+    },
+    anonymousId: {
+      type: 'string',
+      required: false,
+      description: "The user's anonymous identifier when no user ID is available.",
+      label: 'Anonymous ID',
+      default: {
+        '@path': '$.anonymousId'
+      }
+    },
+    traits: {
+      type: 'object',
+      required: false,
+      description: 'User traits and properties to be sent to FullSession.',
+      label: 'User Traits',
+      default: {
+        '@path': '$.traits'
+      }
+    }
+  },
+  perform: (FUS, data) => {
+    const { userId, anonymousId, traits = {} } = data.payload
+
+    // Build the user traits object for identify
+    const identifyTraits = {
+      name: (traits.name as string) ?? '',
+      email: (traits.email as string) ?? ''
+    }
+
+    // call the identify function on either the userId or anonymousId
+
+    FUS.identify(userId ?? (anonymousId as string), identifyTraits)
+
+    // Remove name and email from traits before sending to setSessionAttributes
+    const { name: _ignoredName, email: _ignoredEmail, ...restTraits } = traits || {}
+
+    // Build session attributes
+    const sessionAttributes = {
+      ...restTraits,
+      ...(anonymousId ? { segmentAnonymousId: anonymousId } : {})
+    }
+
+    FUS.setSessionAttributes(sessionAttributes)
+  }
+}
+
+export default action

package/src/index.ts

@@ -0,0 +1,68 @@
+import type { Settings } from './generated-types'
+import type { BrowserDestinationDefinition } from '@segment/browser-destination-runtime/types'
+import { browserDestination } from '@segment/browser-destination-runtime/shim'
+import type { FUS } from './types'
+import { fullSessionTracker } from './types'
+import identifyUser from './identifyUser'
+import { defaultValues } from '@segment/actions-core'
+
+import recordEvent from './recordEvent'
+
+import visitPage from './visitPage'
+
+declare global {
+  interface Window {
+    FUS: FUS
+  }
+}
+// Switch from unknown to the partner SDK client types
+export const destination: BrowserDestinationDefinition<Settings, FUS> = {
+  name: 'FullSession',
+  slug: 'actions-fullsession',
+  mode: 'device',
+  presets: [
+    {
+      name: 'Identify User',
+      subscribe: 'type = "identify"',
+      partnerAction: 'identifyUser',
+      mapping: defaultValues(identifyUser.fields),
+      type: 'automatic'
+    },
+    {
+      name: 'Record Event',
+      subscribe: 'type = "track"',
+      partnerAction: 'recordEvent',
+      mapping: defaultValues(recordEvent.fields),
+      type: 'automatic'
+    },
+    {
+      name: 'Visit Page',
+      subscribe: 'type = "page"',
+      partnerAction: 'visitPage',
+      mapping: defaultValues(visitPage.fields),
+      type: 'automatic'
+    }
+  ],
+  settings: {
+    customerId: {
+      description: 'Your FullSession Customer ID. You can find this in your FullSession dashboard under Settings .',
+      label: 'Customer ID',
+      type: 'string',
+      required: true
+    }
+  },
+
+  initialize: async ({ settings }, deps) => {
+    fullSessionTracker.initialize(settings.customerId)
+    await deps.resolveWhen(() => Object.prototype.hasOwnProperty.call(window, 'FUS'), 1000)
+    return fullSessionTracker
+  },
+
+  actions: {
+    identifyUser,
+    recordEvent,
+    visitPage
+  }
+}
+
+export default browserDestination(destination)