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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reservamos/browser-analytics",
-  "version": "1.1.8-alpha.2",
+  "version": "1.1.8-alpha.3",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/reservamos/reservamos-browser-analytics.git"

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.ts

@@ -1,9 +1,9 @@
 import type { IdentifyReporter } from '@/util/identifyAttempt';
-import { createAnonymousProfileForIdentify } from '@/profiles/createAnonymousProfile/createAnonymousProfile';
 import configService from '@/services/config';
 import { getFingerprintForIdentify } from '@/services/fingerprint';
 import geolocationService from '@/services/geolocation';
 import mixpanelService from '@/services/mixpanel';
+import profileEnrichment from '@/services/profileEnrichment';
 import trackingLifecycle from '@/services/trackingLifecycle';
 import validatorService from '@/services/validator';
 import {
@@ -120,13 +120,10 @@ async function enrichProfileAndLocation(
   isActive: () => boolean,
   report: IdentifyReporter,
 ): Promise<void> {
-  const profile = await waitForIdentifyStage(
-    'profile',
-    3000,
-    (context) =>
-      isActive()
-        ? createAnonymousProfileForIdentify({ ...properties }, context.report)
-        : Promise.resolve(undefined),
+  const profile = await profileEnrichment.enrich(
+    userId,
+    properties,
+    isActive,
     report,
   );
   if (!isActive()) return;
@@ -134,16 +131,6 @@ async function enrichProfileAndLocation(
     ...properties,
     ...(profile && { reservamos_one_id: profile.id }),
   };
-  if (profile) {
-    try {
-      mixpanelService.setPeopleProperties(
-        { reservamos_one_id: profile.id },
-        report,
-      );
-    } catch {
-      report('profile', 'failed');
-    }
-  }
   void identifyWithLocation(userId, enriched, report);
 }
 

package/src/init.ts

@@ -4,6 +4,7 @@ import configService from '@/services/config';
 import fingerprintService from '@/services/fingerprint';
 import geolocationService from '@/services/geolocation';
 import mixpanelService from '@/services/mixpanel';
+import profileEnrichment from '@/services/profileEnrichment';
 import validator, { InitConfigSchema } from '@/services/validator';
 
 /**
@@ -51,12 +52,20 @@ async function init(config: InitConfig) {
   if (appName) {
     configService.setAppName(appName);
   }
-  coreApi.setConfig(configService.getCoreAPIConfig());
+  const coreConfig = configService.getCoreAPIConfig();
+  coreApi.setConfig(coreConfig);
 
   // Dispatch the 'Tracker Ready' event
   onLoaded();
   if (!isCurrent()) return;
 
+  profileEnrichment.initialize({
+    project: mixpanelToken,
+    proxy: mixpanelProxyUrl,
+    apiBaseUrl: coreConfig.baseUrl,
+    appName: coreConfig.defaultHeaders?.['x-app-name'],
+  });
+
   await Promise.all([
     initializeOptionalStage('fingerprint', () =>
       isCurrent()

package/src/profiles/createAnonymousProfile/createAnonymousProfile.ts

@@ -87,6 +87,16 @@ async function requestAnonymousProfile(
   payload: CreateAnonymousProfileProps,
   report?: IdentifyReporter,
 ): Promise<AnonymousProfile | undefined> {
+  return requestPreparedAnonymousProfile(
+    prepareAnonymousProfileForIdentify(payload, report),
+  );
+}
+
+/** Captures exactly the normalized Core request, including its original identifiers. */
+export function prepareAnonymousProfileForIdentify(
+  payload: CreateAnonymousProfileProps,
+  report?: IdentifyReporter,
+): CreateAnonymousProfilePayload {
   validatorService.validateProps(payload, CreateAnonymousProfileSchema);
 
   const identifiers: AnonymousIdentifier[] = [];
@@ -108,8 +118,14 @@ async function requestAnonymousProfile(
     identifiers.push({ key: 'fingerprint', value: userFingerprintId });
   if (distinctId) identifiers.push({ key: 'distinct_id', value: distinctId });
 
-  const dataPayload = getAnonymousProfilePayload(payload, identifiers);
-  return await coreApi.profiles.createAnonymousProfile(dataPayload);
+  return getAnonymousProfilePayload(payload, identifiers);
+}
+
+/** Sends a captured request without rebuilding identifiers from destination state. */
+export function requestPreparedAnonymousProfile(
+  payload: CreateAnonymousProfilePayload,
+): Promise<AnonymousProfile> {
+  return coreApi.profiles.createAnonymousProfile(payload);
 }
 
 export default createAnonymousProfile;

package/src/services/mixpanel.batch.test.ts

@@ -0,0 +1,108 @@
+import mixpanel from 'mixpanel-browser';
+import { afterAll, beforeAll, expect, it, vi } from 'vitest';
+import mixpanelService from './mixpanel';
+
+interface BatchPayload {
+  event?: string;
+  properties?: Record<string, unknown>;
+  $distinct_id?: string;
+  $set?: Record<string, unknown>;
+}
+
+// Keep the real identity handling, batching, storage, and timers; replace HTTP only.
+const transport = mixpanel as unknown as {
+  _send_request(
+    url: string,
+    data: { data: string },
+    options: object,
+    callback?: (response: number) => void,
+  ): boolean;
+  stop_batch_senders(): void;
+  _flags: { identify_called: boolean };
+};
+const batches: { url: string; payload: BatchPayload[] }[] = [];
+
+beforeAll(async () => {
+  vi.useFakeTimers();
+  localStorage.clear();
+  await mixpanelService.init('one-second-batching-token');
+  vi.spyOn(transport, '_send_request').mockImplementation(
+    (url, data, _options, callback) => {
+      if (url.endsWith('/track/') || url.endsWith('/engage/')) {
+        batches.push({
+          url,
+          payload: JSON.parse(data.data) as BatchPayload[],
+        });
+      }
+      callback?.(1);
+      return true;
+    },
+  );
+});
+
+afterAll(() => {
+  transport.stop_batch_senders();
+  vi.restoreAllMocks();
+  vi.clearAllTimers();
+  vi.useRealTimers();
+  localStorage.clear();
+});
+
+it('batches native identity and people updates within one second', async () => {
+  mixpanelService.identify('redirect-user', { $email: 'redirect@example.com' });
+
+  await vi.advanceTimersByTimeAsync(999);
+  expect(batches).toEqual([]);
+
+  await vi.advanceTimersByTimeAsync(1);
+  expect(batches).toHaveLength(2);
+  expect(batches.find(({ url }) => url.endsWith('/track/'))?.payload).toEqual([
+    expect.objectContaining({
+      event: '$identify',
+      properties: expect.objectContaining({ distinct_id: 'redirect-user' }),
+    }),
+  ]);
+  expect(
+    batches.find(({ url }) => url.endsWith('/engage/'))?.payload,
+  ).toContainEqual(
+    expect.objectContaining({
+      $distinct_id: 'redirect-user',
+      $set: expect.objectContaining({ $email: 'redirect@example.com' }),
+    }),
+  );
+});
+
+it('restores people readiness for the unchanged user without another native identity event', async () => {
+  mixpanelService.identify('restored-user', {});
+  await vi.advanceTimersByTimeAsync(1000);
+  batches.length = 0;
+  transport._flags.identify_called = false;
+  const accepted = vi.fn();
+  const report = vi.fn();
+
+  mixpanelService.restorePeopleProperties(
+    'other-user',
+    { reservamos_one_id: 'wrong' },
+    report,
+    accepted,
+  );
+  expect(accepted).not.toHaveBeenCalled();
+
+  mixpanelService.restorePeopleProperties(
+    'restored-user',
+    { reservamos_one_id: 42 },
+    report,
+    accepted,
+  );
+  expect(accepted).toHaveBeenCalledTimes(1);
+  await vi.advanceTimersByTimeAsync(1000);
+  expect(batches).toHaveLength(1);
+  expect(batches[0].url).toContain('/engage/');
+  expect(batches[0].payload).toContainEqual(
+    expect.objectContaining({
+      $distinct_id: 'restored-user',
+      $set: expect.objectContaining({ reservamos_one_id: 42 }),
+    }),
+  );
+  expect(report).not.toHaveBeenCalled();
+});

package/src/services/mixpanel.ts

@@ -59,6 +59,7 @@ function init(
   return new Promise<void>((resolve) => {
     mixpanel.init(mixpanelToken, {
       debug,
+      batch_flush_interval_ms: 1000,
       loaded: () => {
         if (attempt !== initialization) {
           resolve();
@@ -131,32 +132,47 @@ function attachProperty(key: string, value: unknown): void {
 function setPeopleProperties(
   properties: Record<string, unknown>,
   report?: IdentifyReporter,
+  onAccepted?: () => void,
 ): void {
   if (!isReady()) {
     return;
   }
 
-  writePeopleProperties(properties, report);
+  writePeopleProperties(properties, report, onAccepted);
+}
+
+/** Restores people readiness only when the native persisted identity still matches. */
+function restorePeopleProperties(
+  userId: string,
+  properties: Record<string, unknown>,
+  report: IdentifyReporter,
+  onAccepted: () => void,
+): void {
+  if (!isReady() || mixpanel.get_distinct_id() !== userId) return;
+  mixpanel.identify(userId);
+  writePeopleProperties(properties, report, onAccepted);
 }
 
 function writePeopleProperties(
   properties: Record<string, unknown>,
   report?: IdentifyReporter,
+  onAccepted?: () => void,
 ): void {
-  if (!report) {
+  if (!report && !onAccepted) {
     mixpanel.people.set(properties);
     return;
   }
-  const observer = observeIdentifyResult('people', report);
+  const observer = report ? observeIdentifyResult('people', report) : undefined;
   try {
     mixpanel.people.set(properties, (response) => {
       const status = typeof response === 'number' ? response : response?.status;
-      observer.complete(
+      if (status === 1) onAccepted?.();
+      observer?.complete(
         status === 1 ? undefined : status === 0 ? 'failed' : 'unconfirmed',
       );
     });
   } catch {
-    observer.complete('failed');
+    observer?.complete('failed');
   }
 }
 
@@ -224,6 +240,7 @@ const mixpanelService = {
   identify,
   attachProperty,
   setPeopleProperties,
+  restorePeopleProperties,
   getMixpanelDistinctId,
 };