@reservamos/browser-analytics 1.1.6 → 1.1.7-alpha.1

package/package.json

@@ -1,23 +1,19 @@
 {
   "name": "@reservamos/browser-analytics",
-  "version": "1.1.6",
+  "version": "1.1.7-alpha.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/reservamos/reservamos-browser-analytics.git"
   },
-  "main": "./dist/reservamos-browser-analytics.cjs",
-  "module": "./dist/reservamos-browser-analytics.esm.js",
+  "main": "./dist/browser-analytics.cjs",
+  "module": "./dist/browser-analytics.esm.js",
   "exports": {
     ".": {
       "require": "./dist/browser-analytics.cjs",
       "import": "./dist/browser-analytics.esm.js",
       "types": "./dist/browser-analytics.d.ts"
     },
-    "./dist/": {
-      "import": "./dist/",
-      "require": "./dist/",
-      "types": "./dist/"
-    }
+    "./dist/*": "./dist/*"
   },
   "bugs": {
     "url": "https://github.com/reservamos/reservamos-browser-analytics/issues"
@@ -32,7 +28,7 @@
     "package.json"
   ],
   "homepage": "https://github.com/reservamos/reservamos-browser-analytics#readme",
-  "jsdelivr": "./dist/reservamos-browser-analytics.iife.js",
+  "jsdelivr": "./dist/browser-analytics.iife.js",
   "keywords": [
     "analytics",
     "browser"
@@ -49,21 +45,27 @@
     "build": "tsc && vite build",
     "postbuild": "dts-bundle-generator --config ./dts-bundle-generator.config.ts",
     "test": "vitest",
+    "test:run": "vitest --run",
     "test:coverage": "vitest --coverage",
     "format": "prettier . --write",
+    "format:check": "node scripts/check-format.mjs",
+    "lint": "eslint src/ scripts/",
+    "typecheck": "tsc --noEmit",
+    "validate": "./validate.sh",
+    "validate:full": "./validate.sh --full",
     "upgrade": "upgradeps",
     "release": "npm run build && np"
   },
   "type": "module",
-  "types": "./dist/reservamos-browser-analytics.d.ts",
+  "types": "./dist/browser-analytics.d.ts",
   "typesVersions": {
     "*": {
       "*": [
-        "./dist/reservamos-browser-analytics.d.ts"
+        "./dist/browser-analytics.d.ts"
       ]
     }
   },
-  "typings": "./dist/reservamos-browser-analytics.d.ts",
+  "typings": "./dist/browser-analytics.d.ts",
   "dependencies": {
     "@fingerprintjs/fingerprintjs-pro-spa": "^1.3.3",
     "mixpanel-browser": "^2.55.1",

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

@@ -0,0 +1,220 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import identify from './identify';
+
+const mocks = vi.hoisted(() => ({
+  config: vi.fn(),
+  coordinates: vi.fn(),
+  profile: vi.fn(),
+  ready: vi.fn(),
+  identify: vi.fn(),
+  attach: vi.fn(),
+  fingerprint: vi.fn(),
+  validate: vi.fn(),
+  error: vi.fn(),
+}));
+vi.mock('@/services/config', () => ({
+  default: { getCoreAPIConfig: mocks.config },
+}));
+vi.mock('@/services/geolocation', () => ({
+  default: { getCoordinates: mocks.coordinates },
+}));
+vi.mock('@/profiles/createAnonymousProfile/createAnonymousProfile', () => ({
+  createAnonymousProfileForIdentify: mocks.profile,
+}));
+vi.mock('@/services/mixpanel', () => ({
+  default: {
+    isReady: mocks.ready,
+    identify: mocks.identify,
+    attachProperty: mocks.attach,
+  },
+}));
+vi.mock('@/services/fingerprint', () => ({
+  getFingerprintForIdentify: mocks.fingerprint,
+}));
+vi.mock('@/services/validator', () => ({
+  default: { parseIdentifyProps: mocks.validate },
+}));
+vi.mock('@/track', () => ({ trackEventError: mocks.error }));
+
+describe('identify bounded local attempt', () => {
+  const fetchMock = vi.fn();
+  beforeEach(() => {
+    vi.useFakeTimers();
+    Object.values(mocks).forEach((mock) => mock.mockReset());
+    fetchMock.mockReset().mockResolvedValue({ ok: true, status: 200 });
+    vi.stubGlobal('fetch', fetchMock);
+    vi.spyOn(console, 'error').mockImplementation(() => undefined);
+    mocks.ready.mockReturnValue(true);
+    mocks.profile.mockResolvedValue(undefined);
+    mocks.fingerprint.mockResolvedValue('');
+    mocks.coordinates.mockReturnValue(null);
+    mocks.config.mockReturnValue({
+      baseUrl: 'https://example.test/api',
+      defaultHeaders: { 'x-app-name': 'reservamos-web' },
+    });
+  });
+  afterEach(() => {
+    vi.clearAllTimers();
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+    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;
+      }),
+    );
+    let finished = false;
+    const pending = identify('user', { email: 'test@example.com' }).then(() => {
+      finished = true;
+    });
+    await vi.advanceTimersByTimeAsync(1);
+    expect(finished).toBe(false);
+    expect(mocks.identify).not.toHaveBeenCalled();
+    finish({ id: 'profile' });
+    await pending;
+    expect(mocks.identify).toHaveBeenCalledWith(
+      'user',
+      expect.objectContaining({ reservamos_one_id: 'profile' }),
+      expect.any(Function),
+    );
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it('runs readiness once and removes its listener', async () => {
+    mocks.ready.mockReturnValue(false);
+    const remove = vi.spyOn(window, 'removeEventListener');
+    const pending = identify('user');
+    mocks.ready.mockReturnValue(true);
+    window.dispatchEvent(new CustomEvent('Tracker Ready'));
+    window.dispatchEvent(new CustomEvent('Tracker Ready'));
+    await pending;
+    expect(mocks.identify).toHaveBeenCalledTimes(1);
+    expect(remove).toHaveBeenCalledWith('Tracker Ready', expect.any(Function));
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it('expires readiness without a diagnostic listener or late execution', async () => {
+    mocks.ready.mockReturnValue(false);
+    const add = vi.spyOn(window, 'addEventListener');
+    const pending = identify('private-id');
+    await vi.advanceTimersByTimeAsync(5000);
+    await pending;
+    mocks.ready.mockReturnValue(true);
+    window.dispatchEvent(new CustomEvent('Tracker Ready'));
+    expect(mocks.identify).not.toHaveBeenCalled();
+    expect(mocks.error).not.toHaveBeenCalled();
+    expect(
+      add.mock.calls.filter(([name]) => name === 'Tracker Ready'),
+    ).toHaveLength(1);
+    expect(console.error).toHaveBeenCalledWith('Identify diagnostic', {
+      stage: 'readiness',
+      reason: 'timeout',
+    });
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it('continues after profile timeout and ignores its late result', async () => {
+    let finish: (value: { id: string }) => void = () => undefined;
+    mocks.profile.mockReturnValue(
+      new Promise((resolve) => {
+        finish = resolve;
+      }),
+    );
+    const properties = { email: 'test@example.com' };
+    const pending = identify('user', properties);
+    await vi.advanceTimersByTimeAsync(3000);
+    await pending;
+    finish({ id: 'late-profile' });
+    await vi.advanceTimersByTimeAsync(0);
+    expect(mocks.identify).toHaveBeenCalledTimes(1);
+    expect(properties).not.toHaveProperty('reservamos_one_id');
+    expect(mocks.error).toHaveBeenCalledWith('Identify', expect.any(Error), {
+      stage: 'profile',
+      reason: 'timeout',
+    });
+  });
+
+  it('continues after profile rejection with controlled diagnostics', async () => {
+    mocks.profile.mockRejectedValue(new Error('private@example.com'));
+    await identify('private-id');
+    expect(mocks.identify).toHaveBeenCalledTimes(1);
+    expect(mocks.error).toHaveBeenCalledWith(
+      'Identify',
+      expect.objectContaining({ message: 'Identify profile: failed' }),
+      { stage: 'profile', reason: 'failed' },
+    );
+    expect(console.error).not.toHaveBeenCalled();
+  });
+
+  it('expires fingerprint and consumes its late rejection', async () => {
+    let reject: (reason: Error) => void = () => undefined;
+    mocks.fingerprint.mockReturnValue(
+      new Promise((_resolve, fail) => {
+        reject = fail;
+      }),
+    );
+    const pending = identify('user');
+    await vi.advanceTimersByTimeAsync(2000);
+    await pending;
+    reject(new Error('private-id'));
+    await vi.advanceTimersByTimeAsync(0);
+    expect(mocks.attach).not.toHaveBeenCalled();
+    expect(mocks.error).toHaveBeenCalledTimes(1);
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it('starts geolocation without awaiting fetch and aborts at its deadline', async () => {
+    mocks.coordinates.mockReturnValue({ lat: 1, long: 2 });
+    fetchMock.mockReturnValue(new Promise(() => undefined));
+    await identify('user');
+    expect(fetchMock).toHaveBeenCalledWith(
+      'https://example.test/api/v1/datalake/identify',
+      expect.objectContaining({
+        headers: expect.objectContaining({ 'x-app-name': 'reservamos-web' }),
+      }),
+    );
+    const signal = (fetchMock.mock.calls[0][1] as RequestInit).signal;
+    await vi.advanceTimersByTimeAsync(5000);
+    expect(signal?.aborted).toBe(true);
+    expect(mocks.error).toHaveBeenCalledWith('Identify', expect.any(Error), {
+      stage: 'datalake',
+      reason: 'timeout',
+    });
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it.each(['http', 'rejection'])(
+    'observes datalake %s without personal data',
+    async (outcome) => {
+      mocks.coordinates.mockReturnValue({ lat: 1, long: 2 });
+      if (outcome === 'http')
+        fetchMock.mockResolvedValue({ ok: false, status: 500 });
+      else fetchMock.mockRejectedValue(new Error('private@example.com'));
+      await identify('private-id', { email: 'private@example.com' });
+      await vi.advanceTimersByTimeAsync(0);
+      expect(mocks.error).toHaveBeenCalledWith(
+        'Identify',
+        expect.any(Error),
+        outcome === 'http'
+          ? { stage: 'datalake', reason: 'http_error', httpStatus: 500 }
+          : { stage: 'datalake', reason: 'failed' },
+      );
+      expect(JSON.stringify(mocks.error.mock.calls)).not.toContain('private');
+      expect(vi.getTimerCount()).toBe(0);
+    },
+  );
+
+  it('retains the geolocation finally attempt on validation failure', async () => {
+    mocks.validate.mockImplementation(() => {
+      throw new Error('private@example.com');
+    });
+    mocks.coordinates.mockReturnValue({ lat: 1, long: 2 });
+    await identify('user');
+    expect(mocks.identify).not.toHaveBeenCalled();
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+});

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

@@ -17,8 +17,8 @@ vi.mock('@/services/geolocation', () => ({
   },
 }));
 
-vi.mock('@/profiles/createAnonymousProfile', () => ({
-  default: createAnonymousProfileMock,
+vi.mock('@/profiles/createAnonymousProfile/createAnonymousProfile', () => ({
+  createAnonymousProfileForIdentify: createAnonymousProfileMock,
 }));
 
 vi.mock('@/services/mixpanel', () => ({
@@ -31,6 +31,7 @@ vi.mock('@/services/mixpanel', () => ({
 }));
 
 vi.mock('@/services/fingerprint', () => ({
+  getFingerprintForIdentify: vi.fn().mockResolvedValue(null),
   default: {
     getFingerprint: vi.fn().mockResolvedValue(null),
   },
@@ -63,8 +64,8 @@ describe('identify datalake request', () => {
     getCoreAPIConfigMock.mockReturnValue({
       baseUrl: 'https://data-lake.reservamossaas.com/api',
       defaultHeaders: {
-        Authorization: 'Bearer test-token',
-        Origin: 'https://example.com',
+        'Authorization': 'Bearer test-token',
+        'Origin': 'https://example.com',
         'x-app-name': 'reservamos-web',
       },
     });
@@ -74,6 +75,7 @@ describe('identify datalake request', () => {
 
   afterEach(() => {
     vi.restoreAllMocks();
+    vi.unstubAllGlobals();
   });
 
   it('sends x-app-name header on datalake identify request', async () => {

package/src/events/identify/identify.ts

@@ -1,10 +1,16 @@
-import createAnonymousProfile from '@/profiles/createAnonymousProfile';
+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 validatorService from '@/services/validator';
-import { trackEventError, tryTrackEvent } from '@/track';
-import fingerprintService from '../../services/fingerprint';
-import mixpanelService from '../../services/mixpanel';
+import {
+  createIdentifyReporter,
+  observeIdentifyResult,
+  waitForIdentifyReady,
+  waitForIdentifyStage,
+} from '@/util/identifyAttempt';
 import { DefaultProperties } from './identifySchema';
 
 const KNOWN_PROPERTIES = ['firstName', 'lastName', 'email', 'phone'];
@@ -51,7 +57,9 @@ function mapProperties(properties: UserProperties): Record<string, unknown> {
 const identifyWithLocation = async (
   userId: string,
   properties: UserProperties,
+  report: IdentifyReporter,
 ) => {
+  let observer: ReturnType<typeof observeIdentifyResult> | undefined;
   try {
     const coordinates = geolocationService.getCoordinates();
 
@@ -69,25 +77,38 @@ const identifyWithLocation = async (
     delete properties.lastName;
 
     const coreApiConfig = configService.getCoreAPIConfig();
-    fetch(`${coreApiConfig.baseUrl}/v1/datalake/identify`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': coreApiConfig.defaultHeaders?.Authorization || '',
-        'Origin': coreApiConfig.defaultHeaders?.Origin || '',
-        ...(coreApiConfig.defaultHeaders?.['x-app-name']
-          ? { 'x-app-name': coreApiConfig.defaultHeaders['x-app-name'] }
-          : {}),
-      },
-      body: JSON.stringify({
-        profile_params: {
-          ...properties,
-          distinct_id: userId,
+    const controller = new AbortController();
+    observer = observeIdentifyResult('datalake', report, () =>
+      controller.abort(),
+    );
+    const response = await fetch(
+      `${coreApiConfig.baseUrl}/v1/datalake/identify`,
+      {
+        method: 'POST',
+        signal: controller.signal,
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': coreApiConfig.defaultHeaders?.Authorization || '',
+          'Origin': coreApiConfig.defaultHeaders?.Origin || '',
+          ...(coreApiConfig.defaultHeaders?.['x-app-name']
+            ? { 'x-app-name': coreApiConfig.defaultHeaders['x-app-name'] }
+            : {}),
         },
-      }),
-    });
-  } catch (error) {
-    console.error('Error identifying user-service', error);
+        body: JSON.stringify({
+          profile_params: {
+            ...properties,
+            distinct_id: userId,
+          },
+        }),
+      },
+    );
+    observer.complete(
+      response.ok ? undefined : 'http_error',
+      response.ok ? undefined : response.status,
+    );
+  } catch {
+    if (observer) observer.complete('failed');
+    else report('datalake', 'failed');
   }
 };
 
@@ -95,39 +116,60 @@ const identifyWithLocation = async (
  * Identifies a user with given properties and fingerprint.
  * @param {string} userId - The unique identifier for the user.
  * @param {UserProperties} properties - Optional user properties.
- * @throws {Error} If analytics service is not initialized or userId is missing.
- * @returns {Promise<void>}
+ * @returns {Promise<void>} Resolves after a bounded local attempt, not confirmed remote delivery.
  */
 async function identify(
   userId: string,
   properties: UserProperties = {},
 ): Promise<void> {
-  tryTrackEvent(async () => {
+  const report = createIdentifyReporter();
+  if (!(await waitForIdentifyReady(report))) return;
+  try {
     try {
       validatorService.parseIdentifyProps(properties);
-
       if (!userId) {
-        console.error('User ID is required for identification.');
-        throw new Error('User ID is required for identification.');
+        report('validation', 'invalid_input');
+        return;
       }
-      const anonymousProfile = await createAnonymousProfile(properties);
+    } catch {
+      report('validation', 'invalid_input');
+      return;
+    }
+    const anonymousProfile = await waitForIdentifyStage(
+      'profile',
+      3000,
+      (context) =>
+        createAnonymousProfileForIdentify({ ...properties }, context.report),
+      report,
+    );
 
-      if (anonymousProfile) {
-        properties.reservamos_one_id = anonymousProfile.id;
-      }
-      const mappedProps = mapProperties(properties);
-      mixpanelService.identify(userId, mappedProps);
-      const fingerprint = await fingerprintService.getFingerprint();
-      if (fingerprint) {
+    if (anonymousProfile) {
+      properties.reservamos_one_id = anonymousProfile.id;
+    }
+    const mappedProps = mapProperties(properties);
+    try {
+      mixpanelService.identify(userId, mappedProps, report);
+    } catch {
+      report('mixpanel', 'failed');
+    }
+    const fingerprint = await waitForIdentifyStage(
+      'fingerprint',
+      2000,
+      getFingerprintForIdentify,
+      report,
+    );
+    if (fingerprint) {
+      try {
         mixpanelService.attachProperty(FINGERPRINT_PROPERTY, fingerprint);
+      } catch {
+        report('fingerprint', 'failed');
       }
-    } catch (error) {
-      console.error('Error identifying user', error);
-      trackEventError('Identify', error, { userId, properties });
-    } finally {
-      identifyWithLocation(userId, properties);
     }
-  });
+  } catch {
+    report('mixpanel', 'failed');
+  } finally {
+    void identifyWithLocation(userId, properties, report);
+  }
 }
 
 export default identify;

package/src/index.ts

@@ -11,6 +11,7 @@ import type { PurchaseConfirmationProps } from '@/events/purchaseConfirmation';
 import type { SearchProps } from '@/events/search';
 import type { SeatChangeProps } from '@/events/seatChange';
 import type { ViewResultsProps } from '@/events/viewResults';
+import type { InitConfig } from '@/init';
 import type { CreateAnonymousProfileProps } from '@/profiles/createAnonymousProfile';
 import type { CreateFrequentPassengersSchemaProps } from '@/recommendations/createFrequentPassengers';
 import type { CreateRecommendedSeatsSchemaProps } from '@/recommendations/createRecommendedSeats';
@@ -103,6 +104,7 @@ export type {
   DeleteFrequentPassengerProps,
   GeolocationSelectedProps,
   PurchaseConfirmationProps,
+  InitConfig,
 };
 
 export default analytics;

package/src/profiles/createAnonymousProfile/createAnonymousProfile.identify.test.ts

@@ -0,0 +1,56 @@
+import coreApi from '@reservamos/js-api-client/core';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import fingerprintService from '@/services/fingerprint';
+import mixpanelService from '@/services/mixpanel';
+import createAnonymousProfile, {
+  createAnonymousProfileForIdentify,
+} from './createAnonymousProfile';
+
+describe('anonymous profile internal identify path', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('propagates API failure without a raw log, while the public wrapper still returns undefined', async () => {
+    vi.spyOn(fingerprintService, 'getCachedFingerprint').mockReturnValue(null);
+    vi.spyOn(mixpanelService, 'getMixpanelDistinctId').mockReturnValue(null);
+    const error = new Error('private@example.com');
+    vi.spyOn(coreApi.profiles, 'createAnonymousProfile').mockRejectedValue(
+      error,
+    );
+    const log = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+    await expect(
+      createAnonymousProfileForIdentify({ email: 'test@example.com' }, vi.fn()),
+    ).rejects.toBe(error);
+    expect(log).not.toHaveBeenCalled();
+    await expect(
+      createAnonymousProfile({ email: 'test@example.com' }),
+    ).resolves.toBeUndefined();
+  });
+
+  it('omits unreadable optional identifiers and still requests a profile', async () => {
+    const error = new Error('private-id');
+    vi.spyOn(fingerprintService, 'getCachedFingerprint').mockImplementation(
+      () => {
+        throw error;
+      },
+    );
+    vi.spyOn(mixpanelService, 'getMixpanelDistinctId').mockImplementation(
+      () => {
+        throw error;
+      },
+    );
+    const create = vi
+      .spyOn(coreApi.profiles, 'createAnonymousProfile')
+      .mockResolvedValue({ id: 'profile-123' });
+    const report = vi.fn();
+    await createAnonymousProfileForIdentify(
+      { email: 'test@example.com' },
+      report,
+    );
+    expect(create).toHaveBeenCalledWith(
+      expect.objectContaining({ identifiers: [] }),
+    );
+    expect(report).toHaveBeenCalledWith('cache', 'unavailable');
+  });
+});

package/src/profiles/createAnonymousProfile/createAnonymousProfile.ts

@@ -4,6 +4,7 @@ import type {
   CreateAnonymousProfilePayload,
   IdentifierKey,
 } from '@reservamos/js-api-client/core';
+import type { IdentifyReporter } from '@/util/identifyAttempt';
 import type { CreateAnonymousProfileProps } from './createAnonymousProfileSchema';
 import coreApi from '@reservamos/js-api-client/core';
 import fingerprintService from '@/services/fingerprint';
@@ -67,22 +68,48 @@ async function createAnonymousProfile(
   payload: CreateAnonymousProfileProps,
 ): Promise<AnonymousProfile | undefined> {
   try {
-    validatorService.validateProps(payload, CreateAnonymousProfileSchema);
-
-    const identifiers: AnonymousIdentifier[] = [];
-    const userFingerprintId = fingerprintService.getCachedFingerprint();
-    const distinctId = mixpanelService.getMixpanelDistinctId();
-
-    if (userFingerprintId)
-      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 await requestAnonymousProfile(payload);
   } catch (error) {
     console.error('Could not create anonymous profile:', error);
     return undefined;
   }
 }
 
+/** Internal identify path: failures propagate to its bounded, sanitized observer. */
+export function createAnonymousProfileForIdentify(
+  payload: CreateAnonymousProfileProps,
+  report: IdentifyReporter,
+): Promise<AnonymousProfile | undefined> {
+  return requestAnonymousProfile(payload, report);
+}
+
+async function requestAnonymousProfile(
+  payload: CreateAnonymousProfileProps,
+  report?: IdentifyReporter,
+): Promise<AnonymousProfile | undefined> {
+  validatorService.validateProps(payload, CreateAnonymousProfileSchema);
+
+  const identifiers: AnonymousIdentifier[] = [];
+  const readIdentifier = (read: () => string | null) => {
+    if (!report) return read();
+    try {
+      return read();
+    } catch {
+      report('cache', 'unavailable');
+      return null;
+    }
+  };
+  const userFingerprintId = readIdentifier(
+    fingerprintService.getCachedFingerprint,
+  );
+  const distinctId = readIdentifier(mixpanelService.getMixpanelDistinctId);
+
+  if (userFingerprintId)
+    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);
+}
+
 export default createAnonymousProfile;