@reservamos/browser-analytics 1.1.8-alpha.1 → 1.2.0-alpha.0

package/src/services/mixpanel.test.ts

@@ -1,5 +1,4 @@
 import mixpanel from 'mixpanel-browser';
-import { version as mixpanelVersion } from 'mixpanel-browser/package.json';
 import {
   afterAll,
   afterEach,
@@ -13,23 +12,61 @@ import { trackEvent } from '@/track';
 import { version } from '../../package.json';
 import mixpanelService from './mixpanel';
 
-interface TransportData {
-  event?: string;
-  properties?: Record<string, unknown>;
-}
+const { provider } = vi.hoisted(() => ({
+  provider: {
+    init: vi.fn((_token: string, config: { loaded: () => void }) =>
+      config.loaded(),
+    ),
+    register: vi.fn(),
+    set_config: vi.fn(),
+    identify: vi.fn(),
+    track: vi.fn(),
+    get_distinct_id: vi.fn(() => 'live-id'),
+    people: { set: vi.fn(), union: vi.fn() },
+  },
+}));
 
-// Intercept transport only: identify, track, register, and property merging stay real.
-const transport = mixpanel as unknown as {
-  _track_or_batch(options: { data: TransportData }): TransportData;
-  stop_batch_senders(): void;
-};
+// Exercise SDK service methods while replacing the vendor before initialization.
+vi.mock('mixpanel-browser', () => ({ default: provider }));
+
+describe('distinct ID lookup before initialization', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+    localStorage.clear();
+  });
+
+  it.each(['cached', 'empty', 'blocked'])(
+    'uses the %s cache without calling the uninitialized provider',
+    (mode) => {
+      const previous = window.mixpanel;
+      Reflect.deleteProperty(window, 'mixpanel');
+      const lookup = vi
+        .spyOn(mixpanel, 'get_distinct_id')
+        .mockImplementation(() => {
+          throw new Error('Provider persistence is not initialized');
+        });
+      if (mode === 'cached')
+        localStorage.setItem('mp_distinct_id', 'cached-id');
+      if (mode === 'blocked')
+        vi.spyOn(Storage.prototype, 'getItem').mockImplementation(() => {
+          throw new DOMException('Blocked', 'SecurityError');
+        });
+      try {
+        expect(mixpanelService.getMixpanelDistinctId()).toBe(
+          mode === 'cached' ? 'cached-id' : null,
+        );
+        expect(lookup).not.toHaveBeenCalled();
+      } finally {
+        if (previous) window.mixpanel = previous;
+      }
+    },
+  );
+});
 
 describe('Mixpanel SDK version metadata', () => {
   beforeAll(async () => {
     localStorage.clear();
     await mixpanelService.init('test-sdk-version-token');
-    transport.stop_batch_senders();
-    mixpanel.set_config({ disable_persistence: true });
   });
 
   afterEach(() => {
@@ -37,54 +74,30 @@ describe('Mixpanel SDK version metadata', () => {
     vi.unstubAllGlobals();
     vi.clearAllTimers();
     vi.useRealTimers();
+    vi.clearAllMocks();
   });
 
   afterAll(() => {
-    transport.stop_batch_senders();
     localStorage.clear();
   });
 
-  it('registers SDK metadata and propagates it to the native $identify event', () => {
-    expect(mixpanel.get_property('Event Source')).toBe('sdk');
-    expect(mixpanel.get_property('Reservamos Version')).toBe(version);
-
-    const send = vi
-      .spyOn(transport, '_track_or_batch')
-      .mockImplementation(({ data }) => data);
-
-    mixpanelService.identify('sdk-version-user', {});
-    const events = send.mock.calls
-      .map(([options]) => options.data)
-      .filter((data) => data.event);
-
-    expect(events).toHaveLength(1);
-    expect(events[0]).toEqual({
-      event: '$identify',
-      properties: expect.objectContaining({
-        'Event Source': 'sdk',
-        'Reservamos Version': version,
-        '$lib_version': mixpanelVersion,
-      }),
+  it('registers SDK metadata before identifying at the provider boundary', () => {
+    expect(mixpanel.register).toHaveBeenCalledWith({
+      'Event Source': 'sdk',
+      'Reservamos Version': version,
     });
-
-    send.mockClear();
+    expect(mixpanel.register).not.toHaveBeenCalledWith(
+      expect.objectContaining({ $lib_version: expect.anything() }),
+    );
     mixpanelService.identify('sdk-version-user', {});
-    expect(send.mock.calls.some(([options]) => options.data.event)).toBe(false);
+    expect(mixpanel.identify).toHaveBeenCalledWith('sdk-version-user');
+    expect(mixpanel.people.set).toHaveBeenCalledWith({});
   });
 
   it('keeps the SDK version authoritative for SDK-tracked events', () => {
-    const send = vi
-      .spyOn(transport, '_track_or_batch')
-      .mockImplementation(({ data }) => data);
-
     mixpanelService.track('Test', { 'Reservamos Version': 'caller-version' });
-
-    expect(send.mock.calls[0][0].data).toEqual({
-      event: 'Test',
-      properties: expect.objectContaining({
-        'Event Source': 'sdk',
-        'Reservamos Version': version,
-      }),
+    expect(mixpanel.track).toHaveBeenCalledWith('Test', {
+      'Reservamos Version': version,
     });
   });
 
@@ -104,17 +117,12 @@ describe('Mixpanel SDK version metadata', () => {
   });
 
   it('still sets people properties when the SDK distinct ID cache is blocked', () => {
-    vi.spyOn(transport, '_track_or_batch').mockImplementation(
-      ({ data }) => data,
-    );
     vi.spyOn(Storage.prototype, 'setItem').mockImplementation(() => {
       throw new DOMException('Blocked', 'SecurityError');
     });
-    const people = vi
-      .spyOn(mixpanel.people, 'set')
-      .mockImplementation(() => undefined);
     mixpanelService.identify('cache-blocked-user', {});
-    expect(people).toHaveBeenCalledWith({});
+    expect(mixpanel.identify).toHaveBeenCalledWith('cache-blocked-user');
+    expect(mixpanel.people.set).toHaveBeenCalledWith({});
   });
 
   it.each(['getItem', 'setItem'] as const)(
@@ -131,31 +139,33 @@ describe('Mixpanel SDK version metadata', () => {
   it.each(['getItem', 'setItem'] as const)(
     'submits the original event when SDK storage %s is blocked',
     async (method) => {
-      const send = vi
-        .spyOn(transport, '_track_or_batch')
-        .mockImplementation(({ data }) => data);
-      mixpanel.identify('storage-test-id');
-      send.mockClear();
+      vi.spyOn(mixpanel, 'get_distinct_id').mockReturnValue('storage-test-id');
       vi.spyOn(Storage.prototype, method).mockImplementation(() => {
         throw new DOMException('Blocked', 'SecurityError');
       });
       await trackEvent('Storage Failure Test', { source: 'checkout' });
-      expect(send.mock.calls.map(([options]) => options.data)).toContainEqual({
-        event: 'Storage Failure Test',
-        properties: expect.objectContaining({
-          source: 'checkout',
-          distinct_id: 'storage-test-id',
+      expect(mixpanel.track).toHaveBeenCalledWith(
+        'Storage Failure Test',
+        expect.objectContaining({
+          'source': 'checkout',
+          'Reservamos Version': version,
         }),
-      });
+      );
+      expect(mixpanelService.getMixpanelDistinctId()).toBe('storage-test-id');
     },
   );
 
-  it('returns null when no live distinct ID is available and the cache is blocked', () => {
+  it('submits the original event when no live distinct ID is available and the cache is blocked', async () => {
     vi.spyOn(mixpanel, 'get_distinct_id').mockReturnValue('');
     vi.spyOn(Storage.prototype, 'getItem').mockImplementation(() => {
       throw new DOMException('Blocked', 'SecurityError');
     });
     expect(mixpanelService.getMixpanelDistinctId()).toBeNull();
+    await trackEvent('Storage Failure Test', { source: 'checkout' });
+    expect(mixpanel.track).toHaveBeenCalledWith(
+      'Storage Failure Test',
+      expect.objectContaining({ source: 'checkout' }),
+    );
   });
 
   it('uses the live distinct ID first and null fallback when localStorage is null', () => {
@@ -214,9 +224,6 @@ describe('Mixpanel SDK version metadata', () => {
     (response) => {
       vi.useFakeTimers();
       vi.spyOn(mixpanel, 'identify').mockImplementation(() => undefined);
-      vi.spyOn(transport, '_track_or_batch').mockImplementation(
-        ({ data }) => data,
-      );
       let callback: ((response: unknown) => void) | undefined;
       vi.spyOn(mixpanel.people, 'set').mockImplementation((...args) => {
         callback = args[1] as (response: unknown) => void;
@@ -245,9 +252,6 @@ describe('Mixpanel SDK version metadata', () => {
   it('reports missing people callback as unobserved and ignores a late result', () => {
     vi.useFakeTimers();
     vi.spyOn(mixpanel, 'identify').mockImplementation(() => undefined);
-    vi.spyOn(transport, '_track_or_batch').mockImplementation(
-      ({ data }) => data,
-    );
     let callback: ((response: unknown) => void) | undefined;
     vi.spyOn(mixpanel.people, 'set').mockImplementation((...args) => {
       callback = args[1] as (response: unknown) => void;

package/src/services/mixpanel.ts

@@ -105,21 +105,7 @@ function identify(
   trackingLifecycle.identify(userId);
   mixpanel.identify(userId);
   if (!updateCachedDistinctId(userId)) report?.('cache', 'unavailable');
-  if (!report) {
-    mixpanel.people.set(properties);
-    return;
-  }
-  const observer = observeIdentifyResult('people', report);
-  try {
-    mixpanel.people.set(properties, (response) => {
-      const status = typeof response === 'number' ? response : response?.status;
-      observer.complete(
-        status === 1 ? undefined : status === 0 ? 'failed' : 'unconfirmed',
-      );
-    });
-  } catch {
-    observer.complete('failed');
-  }
+  writePeopleProperties(properties, report);
 }
 
 /**
@@ -142,12 +128,36 @@ function attachProperty(key: string, value: unknown): void {
  * Sets people properties for the current Mixpanel user without changing their distinct ID.
  * @param {Record<string, unknown>} properties - Profile properties to set on the current user.
  */
-function setPeopleProperties(properties: Record<string, unknown>): void {
+function setPeopleProperties(
+  properties: Record<string, unknown>,
+  report?: IdentifyReporter,
+): void {
   if (!isReady()) {
     return;
   }
 
-  mixpanel.people.set(properties);
+  writePeopleProperties(properties, report);
+}
+
+function writePeopleProperties(
+  properties: Record<string, unknown>,
+  report?: IdentifyReporter,
+): void {
+  if (!report) {
+    mixpanel.people.set(properties);
+    return;
+  }
+  const observer = observeIdentifyResult('people', report);
+  try {
+    mixpanel.people.set(properties, (response) => {
+      const status = typeof response === 'number' ? response : response?.status;
+      observer.complete(
+        status === 1 ? undefined : status === 0 ? 'failed' : 'unconfirmed',
+      );
+    });
+  } catch {
+    observer.complete('failed');
+  }
 }
 
 /**
@@ -178,7 +188,7 @@ function track(eventName: string, properties: Record<string, unknown>): void {
  * @returns {string | null} The live or cached distinct ID, or null when neither is available.
  */
 export const getMixpanelDistinctId = (): string | null => {
-  const distinctId = mixpanel?.get_distinct_id?.();
+  const distinctId = isReady() ? mixpanel.get_distinct_id() : null;
   if (distinctId) {
     updateCachedDistinctId(distinctId);
     return distinctId;

package/src/track.storage.test.ts

@@ -1,4 +1,5 @@
 import coreApi from '@reservamos/js-api-client/core';
+import mixpanel from 'mixpanel-browser';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import fingerprintService from '@/services/fingerprint';
 import mixpanelService from '@/services/mixpanel';
@@ -10,7 +11,22 @@ const { getVisitorData, init, client } = vi.hoisted(() => ({
   client: vi.fn(),
 }));
 
-// Keep the SDK Fingerprint cache, tracking, validation, and relay real.
+const { provider } = vi.hoisted(() => ({
+  provider: {
+    init: vi.fn((_token: string, config: { loaded: () => void }) =>
+      config.loaded(),
+    ),
+    register: vi.fn(),
+    set_config: vi.fn(),
+    identify: vi.fn(),
+    track: vi.fn(),
+    get_distinct_id: vi.fn(() => 'live-id'),
+    people: { set: vi.fn(), union: vi.fn() },
+  },
+}));
+vi.mock('mixpanel-browser', () => ({ default: provider }));
+
+// Keep the SDK Fingerprint cache, Mixpanel service, tracking, validation, and relay real.
 vi.mock('@fingerprintjs/fingerprintjs-pro-spa', () => ({
   FingerprintJSPro: {
     defaultEndpoint: 'https://fpjscdn.net',
@@ -57,6 +73,7 @@ const checkout = {
 describe('tracking with blocked SDK Fingerprint cache writes', () => {
   beforeEach(async () => {
     localStorage.clear();
+    await mixpanelService.init('test-storage-token');
     client.mockImplementation(() => ({ init, getVisitorData }));
     init.mockResolvedValue(undefined);
     getVisitorData.mockResolvedValue({
@@ -67,14 +84,8 @@ describe('tracking with blocked SDK Fingerprint cache writes', () => {
       cacheHit: false,
     });
     await fingerprintService.initFingerprint('test-api-key');
-    vi.spyOn(mixpanelService, 'isReady').mockReturnValue(true);
-    vi.spyOn(mixpanelService, 'getMixpanelDistinctId').mockReturnValue(
-      'live-id',
-    );
-    vi.spyOn(mixpanelService, 'track').mockImplementation(() => undefined);
-    vi.spyOn(mixpanelService, 'setPeopleProperties').mockImplementation(
-      () => undefined,
-    );
+    vi.spyOn(mixpanel, 'get_distinct_id').mockReturnValue('live-id');
+    vi.spyOn(mixpanel.people, 'set').mockImplementation(() => undefined);
     vi.spyOn(coreApi.fingerprint, 'sendObservation').mockResolvedValue(true);
     vi.spyOn(Storage.prototype, 'setItem').mockImplementation(() => {
       throw new DOMException('Blocked', 'SecurityError');
@@ -96,16 +107,20 @@ describe('tracking with blocked SDK Fingerprint cache writes', () => {
     async (eventName, properties, eligible) => {
       await trackEvent(eventName, properties);
 
-      expect(mixpanelService.track).toHaveBeenCalledOnce();
-      expect(mixpanelService.track).toHaveBeenCalledWith(
+      expect(mixpanel.track).toHaveBeenCalledOnce();
+      expect(mixpanel.track).toHaveBeenCalledWith(
         eventName,
         expect.objectContaining({
           'User Fingerprint': expect.any(String),
           'product': 'web',
         }),
       );
+      /**
+       * Checks effects that may finish after event submission during background refresh.
+       * @returns {void} Throws until the expected profile and relay effects are observed.
+       */
       const verifyIdentificationEffects = () => {
-        expect(mixpanelService.setPeopleProperties).toHaveBeenCalledWith({
+        expect(mixpanel.people.set).toHaveBeenCalledWith({
           'Visitor Found': true,
         });
         expect(coreApi.fingerprint.sendObservation).toHaveBeenCalledTimes(