@reservamos/browser-analytics 1.1.8-alpha.1 → 1.1.8-alpha.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reservamos/browser-analytics",
-  "version": "1.1.8-alpha.1",
+  "version": "1.1.8-alpha.3",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/reservamos/reservamos-browser-analytics.git"
@@ -74,7 +74,7 @@
   "devDependencies": {
     "@eslint/js": "^9.9.1",
     "@ianvs/prettier-plugin-sort-imports": "^4.3.1",
-    "@reservamos/js-api-client": "6.28.0",
+    "@reservamos/js-api-client": "6.28.1",
     "@types/eslint__js": "^8.42.3",
     "@types/jsdom": "^21.1.6",
     "@types/mixpanel-browser": "^2.50.0",

package/src/events/identify/identify.recovery.test.ts

@@ -0,0 +1,367 @@
+import type { InitConfig } from '@/init';
+import { afterEach, beforeEach, expect, it, vi } from 'vitest';
+
+const mocks = vi.hoisted(() => ({
+  profile: vi.fn(),
+  people: vi.fn(),
+  restore: vi.fn(),
+  identify: vi.fn(),
+  user: 'user-a',
+  apiBaseUrl: 'https://core.test',
+  appName: '',
+  fingerprint: null as string | null,
+}));
+vi.mock('@reservamos/js-api-client/core', () => ({
+  default: {
+    setConfig: vi.fn(),
+    profiles: { createAnonymousProfile: mocks.profile },
+  },
+}));
+vi.mock('@/services/mixpanel', async () => {
+  const lifecycle = (await import('@/services/trackingLifecycle')).default;
+  return {
+    default: {
+      init: vi.fn(async () => lifecycle.beginInitialization()),
+      validateConfiguration: vi.fn(),
+      isReady: () => true,
+      getMixpanelDistinctId: () => mocks.user,
+      identify: mocks.identify.mockImplementation((user: string) => {
+        mocks.user = user;
+        lifecycle.identify(user);
+      }),
+      setPeopleProperties: mocks.people,
+      restorePeopleProperties: mocks.restore,
+      attachProperty: vi.fn(),
+      track: vi.fn(),
+    },
+  };
+});
+vi.mock('@/services/fingerprint', () => ({
+  getFingerprintForIdentify: vi.fn().mockResolvedValue(''),
+  default: {
+    initFingerprint: vi.fn().mockResolvedValue(undefined),
+    getCachedFingerprint: () => mocks.fingerprint,
+  },
+}));
+vi.mock('@/services/geolocation', () => ({
+  default: {
+    init: vi.fn().mockResolvedValue(undefined),
+    getCoordinates: () => null,
+    getGeolocationSource: () => null,
+  },
+}));
+vi.mock('@/services/config', () => ({
+  default: {
+    setEnvironment: vi.fn(),
+    setAppName: vi.fn(),
+    getCoreAPIConfig: () => ({
+      baseUrl: mocks.apiBaseUrl,
+      defaultHeaders: { 'x-app-name': mocks.appName },
+    }),
+  },
+}));
+
+const config = { mixpanelToken: 'recovery-project', identificationKey: 'test' };
+let init: typeof import('@/init').default;
+let identify: typeof import('./identify').default;
+
+async function loadDestination(destinationConfig: InitConfig = config) {
+  const now = Date.now();
+  vi.clearAllTimers();
+  vi.setSystemTime(now);
+  vi.resetModules();
+  init = (await import('@/init')).default;
+  identify = (await import('./identify')).default;
+  await init(destinationConfig);
+  await vi.advanceTimersByTimeAsync(0);
+}
+
+beforeEach(async () => {
+  vi.useFakeTimers();
+  vi.resetModules();
+  sessionStorage.clear();
+  localStorage.clear();
+  mocks.user = 'user-a';
+  mocks.apiBaseUrl = 'https://core.test';
+  mocks.appName = '';
+  mocks.fingerprint = null;
+  mocks.profile.mockReset();
+  mocks.people
+    .mockReset()
+    .mockImplementation((_props, _report, accepted?: () => void) =>
+      accepted?.(),
+    );
+  mocks.restore
+    .mockReset()
+    .mockImplementation((_user, _props, _report, accepted?: () => void) =>
+      accepted?.(),
+    );
+  mocks.identify.mockReset();
+  vi.spyOn(console, 'error').mockImplementation(() => undefined);
+  init = (await import('@/init')).default;
+  identify = (await import('./identify')).default;
+  await init(config);
+});
+afterEach(() => {
+  vi.clearAllTimers();
+  vi.useRealTimers();
+  vi.restoreAllMocks();
+});
+
+it('recovers a lost profile response on destination init without consumer identify', async () => {
+  mocks.profile.mockReturnValueOnce(new Promise(() => undefined));
+  await identify('user-a', {
+    email: 'a@example.com',
+    firstName: 'Original name',
+    customField: 'Not persisted',
+  });
+  expect(sessionStorage.length).toBe(1);
+  const stored = sessionStorage.getItem(sessionStorage.key(0) || '') || '';
+  expect(stored).toContain('a@example.com');
+  expect(stored).not.toContain('Not persisted');
+
+  mocks.profile.mockResolvedValueOnce({ id: 'profile-a' });
+  await loadDestination();
+
+  expect(mocks.profile).toHaveBeenCalledTimes(2);
+  expect(mocks.restore).toHaveBeenCalledWith(
+    'user-a',
+    { reservamos_one_id: 'profile-a' },
+    expect.any(Function),
+    expect.any(Function),
+  );
+  expect(mocks.identify).toHaveBeenCalledTimes(1);
+  expect(sessionStorage.length).toBe(0);
+});
+
+it('keeps a resolved numeric profile ID until people acceptance and drops the contact identifier', async () => {
+  mocks.people.mockImplementation(() => undefined);
+  mocks.profile.mockResolvedValue({ id: 42 });
+  await identify('user-a', { email: 'a@example.com' });
+  await vi.advanceTimersByTimeAsync(0);
+  const stored = sessionStorage.getItem(sessionStorage.key(0) || '') || '';
+  expect(JSON.parse(stored)).toEqual(
+    expect.objectContaining({ profileId: 42 }),
+  );
+  expect(stored).not.toContain('a@example.com');
+  await loadDestination();
+  expect(mocks.profile).toHaveBeenCalledTimes(1);
+  expect(mocks.restore).toHaveBeenCalledWith(
+    'user-a',
+    { reservamos_one_id: 42 },
+    expect.any(Function),
+    expect.any(Function),
+  );
+  expect(sessionStorage.length).toBe(0);
+});
+
+it('does not resume an intent for a different persisted user', async () => {
+  mocks.profile.mockReturnValue(new Promise(() => undefined));
+  await identify('user-a', { email: 'a@example.com' });
+  mocks.user = 'user-b';
+  await loadDestination();
+  expect(mocks.profile).toHaveBeenCalledTimes(1);
+  expect(mocks.restore).not.toHaveBeenCalled();
+  expect(sessionStorage.length).toBe(0);
+});
+
+it.each(['project', 'proxy', 'core', 'application'])(
+  'does not resume an intent with a different %s',
+  async (change) => {
+    mocks.profile.mockReturnValue(new Promise(() => undefined));
+    await identify('user-a', { email: 'a@example.com' });
+    const destination: InitConfig = { ...config };
+    if (change === 'project') destination.mixpanelToken = 'other-project';
+    if (change === 'proxy')
+      destination.mixpanelProxyUrl = 'https://other-proxy.test';
+    if (change === 'core') mocks.apiBaseUrl = 'https://other-core.test';
+    if (change === 'application') mocks.appName = 'other-app';
+    await loadDestination(destination);
+    expect(mocks.profile).toHaveBeenCalledTimes(1);
+    expect(mocks.restore).not.toHaveBeenCalled();
+    expect(sessionStorage.length).toBe(0);
+  },
+);
+
+it('recovers a phone-only profile and preserves its original user identifier', async () => {
+  mocks.profile.mockReturnValueOnce(new Promise(() => undefined));
+  await identify('user-a', { phone: '+525500000000' });
+  mocks.profile.mockResolvedValueOnce({ id: 'phone-profile' });
+  await loadDestination();
+  expect(mocks.profile.mock.calls[1][0]).toEqual(
+    expect.objectContaining({
+      identifier_key: 'phone',
+      identifier_value: '+525500000000',
+      identifiers: [{ key: 'distinct_id', value: 'user-a' }],
+    }),
+  );
+  expect(mocks.restore).toHaveBeenCalledWith(
+    'user-a',
+    { reservamos_one_id: 'phone-profile' },
+    expect.any(Function),
+    expect.any(Function),
+  );
+});
+
+it('bounds a stalled request without retrying until another initialization', async () => {
+  mocks.profile.mockReturnValueOnce(new Promise(() => undefined));
+  await identify('user-a', { email: 'a@example.com' });
+  await vi.advanceTimersByTimeAsync(3100);
+  expect(mocks.profile).toHaveBeenCalledTimes(1);
+  expect(sessionStorage.length).toBe(1);
+  mocks.profile.mockResolvedValueOnce({ id: 'recovered-profile' });
+  await loadDestination();
+  expect(mocks.profile).toHaveBeenCalledTimes(2);
+  expect(sessionStorage.length).toBe(0);
+});
+
+it.each(['user-a', 'user-b'])(
+  'does not let a superseded response overwrite or clear a replacement intent for %s',
+  async (nextUser) => {
+    let finish!: (profile: { id: string }) => void;
+    mocks.profile.mockReturnValueOnce(
+      new Promise((resolve) => {
+        finish = resolve;
+      }),
+    );
+    await identify('user-a', { email: 'old@example.com' });
+    mocks.profile.mockReturnValueOnce(new Promise(() => undefined));
+    await identify(nextUser, { email: 'new@example.com' });
+    finish({ id: 'old-profile' });
+    await vi.advanceTimersByTimeAsync(0);
+    expect(
+      mocks.people.mock.calls.some(
+        ([properties]) => properties.reservamos_one_id === 'old-profile',
+      ),
+    ).toBe(false);
+    const entry = JSON.parse(
+      sessionStorage.getItem(sessionStorage.key(0) || '') || '{}',
+    );
+    expect(entry.userId).toBe(nextUser);
+    expect(entry.request.identifier_value).toBe('new@example.com');
+  },
+);
+
+it('rejects expired recovery work on initialization', async () => {
+  mocks.profile.mockReturnValue(new Promise(() => undefined));
+  await identify('user-a', { email: 'a@example.com' });
+  vi.setSystemTime(Date.now() + 10 * 60 * 1000 + 1);
+  await loadDestination();
+  expect(mocks.profile).toHaveBeenCalledTimes(1);
+  expect(sessionStorage.length).toBe(0);
+});
+
+it.each(['{invalid', JSON.stringify({ version: 99 }), 'x'.repeat(4097)])(
+  'discards invalid persisted work without requesting a profile',
+  async (entry) => {
+    sessionStorage.setItem('reservamos_pending_profile_v1', entry);
+    await loadDestination();
+    expect(mocks.profile).not.toHaveBeenCalled();
+    expect(sessionStorage.length).toBe(0);
+    expect(mocks.restore).not.toHaveBeenCalled();
+  },
+);
+
+it('limits failed profile HTTP attempts across page initialization', async () => {
+  mocks.profile.mockRejectedValue(new Error('private backend error'));
+  await identify('user-a', { email: 'a@example.com' });
+  await vi.advanceTimersByTimeAsync(0);
+  await loadDestination();
+  await loadDestination();
+  await loadDestination();
+  expect(mocks.profile).toHaveBeenCalledTimes(3);
+  expect(sessionStorage.length).toBe(0);
+  expect(JSON.stringify(vi.mocked(console.error).mock.calls)).not.toContain(
+    'private backend error',
+  );
+});
+
+it('preserves normal enrichment when session storage is blocked', async () => {
+  vi.spyOn(Storage.prototype, 'setItem').mockImplementation(function (
+    this: Storage,
+  ) {
+    if (this === sessionStorage)
+      throw new DOMException('Blocked', 'SecurityError');
+  });
+  mocks.profile.mockResolvedValue({ id: 'profile-a' });
+  await identify('user-a', { email: 'a@example.com' });
+  await vi.advanceTimersByTimeAsync(0);
+  expect(mocks.identify).toHaveBeenCalledTimes(1);
+  expect(mocks.people).toHaveBeenCalledWith(
+    { reservamos_one_id: 'profile-a' },
+    expect.any(Function),
+    expect.any(Function),
+  );
+  expect(sessionStorage.length).toBe(0);
+});
+
+it('replays the complete original Core request with unchanged details and identifiers', async () => {
+  mocks.fingerprint = 'original-fingerprint';
+  mocks.profile.mockReturnValueOnce(new Promise(() => undefined));
+  await identify('user-a', {
+    email: 'new@example.com',
+    phone: '+525500000001',
+    cpf: '12345678900',
+    firstName: 'Original',
+    lastName: 'Name',
+  });
+  const original = mocks.profile.mock.calls[0][0];
+  expect(original.details).toEqual({ firstName: 'Original', lastName: 'Name' });
+  expect(original.identifiers).toContainEqual({
+    key: 'phone',
+    value: '+525500000001',
+  });
+  expect(original.identifiers).toContainEqual({
+    key: 'fingerprint',
+    value: 'original-fingerprint',
+  });
+  mocks.fingerprint = 'destination-fingerprint';
+  mocks.profile.mockImplementationOnce(async (request) => ({
+    id: request.identifiers.some(
+      (identifier: { key: string; value: string }) =>
+        identifier.key === 'phone' && identifier.value === '+525500000001',
+    )
+      ? 'strong-phone-profile'
+      : 'weak-user-profile',
+  }));
+  await loadDestination();
+  expect(mocks.profile.mock.calls[1][0]).toEqual(original);
+  expect(mocks.restore).toHaveBeenCalledWith(
+    'user-a',
+    { reservamos_one_id: 'strong-phone-profile' },
+    expect.any(Function),
+    expect.any(Function),
+  );
+});
+
+it('removes superseded recovery intent when replacing its storage record fails', async () => {
+  mocks.profile.mockReturnValue(new Promise(() => undefined));
+  await identify('user-a', { email: 'old@example.com' });
+  const setItem = Storage.prototype.setItem;
+  vi.spyOn(Storage.prototype, 'setItem').mockImplementation(function (
+    this: Storage,
+    key,
+    value,
+  ) {
+    if (this === sessionStorage) throw new Error('write unavailable');
+    return setItem.call(this, key, value);
+  });
+  await identify('user-a', { email: 'new@example.com' });
+  expect(sessionStorage.length).toBe(0);
+  await loadDestination();
+  expect(mocks.profile).toHaveBeenCalledTimes(2);
+});
+
+it('does not retry when the attempt count cannot be persisted', async () => {
+  mocks.profile.mockReturnValue(new Promise(() => undefined));
+  await identify('user-a', { email: 'a@example.com' });
+  vi.spyOn(Storage.prototype, 'setItem').mockImplementation(() => {
+    throw new Error('blocked');
+  });
+  vi.spyOn(Storage.prototype, 'removeItem').mockImplementation(() => {
+    throw new Error('blocked');
+  });
+  await loadDestination();
+  await loadDestination();
+  expect(mocks.profile).toHaveBeenCalledTimes(1);
+});

package/src/events/identify/identify.robustness.test.ts

@@ -1,4 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import trackingLifecycle from '@/services/trackingLifecycle';
 import identify from './identify';
 
 const mocks = vi.hoisted(() => ({
@@ -8,6 +9,7 @@ const mocks = vi.hoisted(() => ({
   ready: vi.fn(),
   identify: vi.fn(),
   attach: vi.fn(),
+  people: vi.fn(),
   fingerprint: vi.fn(),
   validate: vi.fn(),
   error: vi.fn(),
@@ -26,6 +28,7 @@ vi.mock('@/services/mixpanel', () => ({
     isReady: mocks.ready,
     identify: mocks.identify,
     attachProperty: mocks.attach,
+    setPeopleProperties: mocks.people,
   },
 }));
 vi.mock('@/services/fingerprint', () => ({
@@ -60,30 +63,123 @@ describe('identify bounded local attempt', () => {
     vi.unstubAllGlobals();
   });
 
-  it('awaits the local profile and includes its ID before identifying', async () => {
-    let finish: (value: { id: string }) => void = () => undefined;
-    mocks.profile.mockReturnValue(
-      new Promise((resolve) => {
-        finish = resolve;
-      }),
+  it('submits and resolves before a two-second redirect despite a 2.5-second profile', async () => {
+    mocks.profile.mockImplementation(
+      () =>
+        new Promise((resolve) =>
+          setTimeout(() => resolve({ id: 'profile' }), 2500),
+        ),
     );
+    const properties = { email: 'test@example.com', firstName: 'Test' };
     let finished = false;
-    const pending = identify('user', { email: 'test@example.com' }).then(() => {
+    void identify('user', properties).then(() => {
       finished = true;
     });
     await vi.advanceTimersByTimeAsync(1);
-    expect(finished).toBe(false);
-    expect(mocks.identify).not.toHaveBeenCalled();
-    finish({ id: 'profile' });
-    await pending;
+    expect(finished).toBe(true);
     expect(mocks.identify).toHaveBeenCalledWith(
       'user',
-      expect.objectContaining({ reservamos_one_id: 'profile' }),
+      expect.objectContaining({ $email: 'test@example.com' }),
       expect.any(Function),
     );
-    expect(vi.getTimerCount()).toBe(0);
+    expect(mocks.people).not.toHaveBeenCalled();
+    await vi.advanceTimersByTimeAsync(1999);
+    expect(mocks.identify).toHaveBeenCalledTimes(1);
+    await vi.advanceTimersByTimeAsync(500);
+    expect(mocks.people).toHaveBeenCalledWith(
+      { reservamos_one_id: 'profile' },
+      expect.any(Function),
+    );
+    expect(mocks.identify).toHaveBeenCalledTimes(1);
+    expect(properties).toEqual({
+      email: 'test@example.com',
+      firstName: 'Test',
+    });
   });
 
+  it.each(['new-user', 'reinitialize'] as const)(
+    'suppresses late enrichment after %s',
+    async (transition) => {
+      let finish!: (value: { id: string }) => void;
+      let finishFingerprint!: (value: string) => void;
+      mocks.fingerprint.mockReturnValueOnce(
+        new Promise((resolve) => {
+          finishFingerprint = resolve;
+        }),
+      );
+      mocks.profile.mockReturnValueOnce(
+        new Promise((resolve) => {
+          finish = resolve;
+        }),
+      );
+      await identify('old-user');
+      if (transition === 'new-user') await identify('new-user');
+      else {
+        trackingLifecycle.beginInitialization();
+        trackingLifecycle.beginInitialization();
+      }
+      finish({ id: 'old-profile' });
+      finishFingerprint('old-fingerprint');
+      await vi.advanceTimersByTimeAsync(0);
+      expect(mocks.people).not.toHaveBeenCalled();
+      expect(mocks.attach).not.toHaveBeenCalled();
+    },
+  );
+
+  it('attaches current fingerprint once', async () => {
+    mocks.fingerprint.mockResolvedValue('current-fingerprint');
+    await identify('user');
+    await vi.advanceTimersByTimeAsync(0);
+    expect(mocks.attach).toHaveBeenCalledWith(
+      'Known Fingerprints',
+      'current-fingerprint',
+    );
+    expect(mocks.attach).toHaveBeenCalledTimes(1);
+  });
+  it('retains the created profile ID in background datalake payload without mutating input', async () => {
+    mocks.profile.mockResolvedValue({ id: 'created-profile' });
+    mocks.coordinates.mockReturnValue({ lat: 1, long: 2 });
+    const properties = {
+      email: 'test@example.com',
+      firstName: 'Test',
+      lastName: 'User',
+    };
+    await identify('user', properties);
+    await vi.advanceTimersByTimeAsync(0);
+    const request = fetchMock.mock.calls[0][1] as RequestInit;
+    expect(JSON.parse(request.body as string).profile_params).toEqual(
+      expect.objectContaining({
+        reservamos_one_id: 'created-profile',
+        distinct_id: 'user',
+        first_name: 'Test',
+        last_name: 'User',
+      }),
+    );
+    expect(properties).toEqual({
+      email: 'test@example.com',
+      firstName: 'Test',
+      lastName: 'User',
+    });
+  });
+  it('does not identify an old user after readiness belongs to a replacement init', async () => {
+    trackingLifecycle.beginInitialization();
+    mocks.ready.mockReturnValue(false);
+    const pending = identify('old-user');
+    trackingLifecycle.beginInitialization();
+    mocks.ready.mockReturnValue(true);
+    window.dispatchEvent(new CustomEvent('Tracker Ready'));
+    await pending;
+    expect(mocks.identify).not.toHaveBeenCalled();
+  });
+  it('does not start optional requests after the attempt is superseded before their microtask', async () => {
+    const pending = identify('old-user');
+    await Promise.resolve();
+    trackingLifecycle.beginInitialization();
+    await pending;
+    await vi.advanceTimersByTimeAsync(0);
+    expect(mocks.profile).not.toHaveBeenCalled();
+    expect(mocks.fingerprint).not.toHaveBeenCalled();
+  });
   it('runs readiness once and removes its listener', async () => {
     mocks.ready.mockReturnValue(false);
     const remove = vi.spyOn(window, 'removeEventListener');
@@ -94,6 +190,7 @@ describe('identify bounded local attempt', () => {
     await pending;
     expect(mocks.identify).toHaveBeenCalledTimes(1);
     expect(remove).toHaveBeenCalledWith('Tracker Ready', expect.any(Function));
+    await vi.advanceTimersByTimeAsync(0);
     expect(vi.getTimerCount()).toBe(0);
   });
 
@@ -141,6 +238,7 @@ describe('identify bounded local attempt', () => {
   it('continues after profile rejection with controlled diagnostics', async () => {
     mocks.profile.mockRejectedValue(new Error('private@example.com'));
     await identify('private-id');
+    await vi.advanceTimersByTimeAsync(0);
     expect(mocks.identify).toHaveBeenCalledTimes(1);
     expect(mocks.error).toHaveBeenCalledWith(
       'Identify',
@@ -171,6 +269,7 @@ describe('identify bounded local attempt', () => {
     mocks.coordinates.mockReturnValue({ lat: 1, long: 2 });
     fetchMock.mockReturnValue(new Promise(() => undefined));
     await identify('user');
+    await vi.advanceTimersByTimeAsync(0);
     expect(fetchMock).toHaveBeenCalledWith(
       'https://example.test/api/v1/datalake/identify',
       expect.objectContaining({