@reservamos/browser-analytics 1.1.2 → 1.1.3-alpha.0

package/package.json

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

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

@@ -0,0 +1,102 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const getCoreAPIConfigMock = vi.fn();
+const getCoordinatesMock = vi.fn();
+const createAnonymousProfileMock = vi.fn();
+const isReadyMock = vi.fn();
+
+vi.mock('@/services/config', () => ({
+  default: {
+    getCoreAPIConfig: getCoreAPIConfigMock,
+  },
+}));
+
+vi.mock('@/services/geolocation', () => ({
+  default: {
+    getCoordinates: getCoordinatesMock,
+  },
+}));
+
+vi.mock('@/profiles/createAnonymousProfile', () => ({
+  default: createAnonymousProfileMock,
+}));
+
+vi.mock('@/services/mixpanel', () => ({
+  default: {
+    isReady: isReadyMock,
+    identify: vi.fn(),
+    attachProperty: vi.fn(),
+    getMixpanelDistinctId: vi.fn(),
+  },
+}));
+
+vi.mock('@/services/fingerprint', () => ({
+  default: {
+    getFingerprint: vi.fn().mockResolvedValue(null),
+  },
+}));
+
+vi.mock('@/services/validator', () => ({
+  default: {
+    parseIdentifyProps: vi.fn(),
+  },
+}));
+
+vi.mock('@/track', () => ({
+  tryTrackEvent: async (callback: () => Promise<void>) => callback(),
+  trackEventError: vi.fn(),
+}));
+
+describe('identify datalake request', () => {
+  const fetchMock = vi.fn().mockResolvedValue({ ok: true });
+
+  beforeEach(() => {
+    vi.resetModules();
+    fetchMock.mockClear();
+    getCoordinatesMock.mockReset();
+    createAnonymousProfileMock.mockReset();
+    getCoreAPIConfigMock.mockReset();
+    isReadyMock.mockReturnValue(true);
+
+    createAnonymousProfileMock.mockResolvedValue(undefined);
+    getCoordinatesMock.mockReturnValue({ lat: 19.4326, long: -99.1332 });
+    getCoreAPIConfigMock.mockReturnValue({
+      baseUrl: 'https://data-lake.reservamossaas.com/api',
+      defaultHeaders: {
+        Authorization: 'Bearer test-token',
+        Origin: 'https://example.com',
+        'x-app-name': 'reservamos-web',
+      },
+    });
+
+    vi.stubGlobal('fetch', fetchMock);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('sends x-app-name header on datalake identify request', async () => {
+    const identify = (await import('./identify')).default;
+
+    await identify('user-123', {
+      email: 'test@example.com',
+      firstName: 'John',
+      lastName: 'Doe',
+    });
+
+    await vi.waitFor(() => {
+      expect(fetchMock).toHaveBeenCalled();
+    });
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      'https://data-lake.reservamossaas.com/api/v1/datalake/identify',
+      expect.objectContaining({
+        method: 'POST',
+        headers: expect.objectContaining({
+          'x-app-name': 'reservamos-web',
+        }),
+      }),
+    );
+  });
+});

package/src/events/identify/identify.ts

@@ -75,6 +75,9 @@ const identifyWithLocation = async (
         '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: {

package/src/init.ts

@@ -36,6 +36,7 @@ async function init(config: InitConfig) {
     isSandbox = false,
     mixpanelProxyUrl,
     identifyProxyUrl,
+    appName,
   } = config;
 
   await mixpanelService.init(mixpanelToken, debug, mixpanelProxyUrl);
@@ -52,6 +53,9 @@ async function init(config: InitConfig) {
   await geolocationService.init();
 
   configService.setEnvironment(isSandbox ? 'sandbox' : 'prod');
+  if (appName) {
+    configService.setAppName(appName);
+  }
   coreApi.setConfig(configService.getCoreAPIConfig());
 
   // Dispatch the 'Tracker Ready' event

package/src/services/config.test.ts

@@ -0,0 +1,39 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+describe('configService', () => {
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  it('includes x-app-name in defaultHeaders after setAppName (prod)', async () => {
+    const configService = (await import('./config')).default;
+
+    configService.setAppName('my-bus-app');
+    configService.setEnvironment('prod');
+
+    const config = configService.getCoreAPIConfig();
+
+    expect(config.defaultHeaders?.['x-app-name']).toBe('my-bus-app');
+  });
+
+  it('includes x-app-name in defaultHeaders after setAppName (sandbox)', async () => {
+    const configService = (await import('./config')).default;
+
+    configService.setAppName('whitelabel-portal');
+    configService.setEnvironment('sandbox');
+
+    const config = configService.getCoreAPIConfig();
+
+    expect(config.defaultHeaders?.['x-app-name']).toBe('whitelabel-portal');
+  });
+
+  it('omits x-app-name from defaultHeaders when setAppName is not called', async () => {
+    const configService = (await import('./config')).default;
+
+    configService.setEnvironment('prod');
+
+    const config = configService.getCoreAPIConfig();
+
+    expect(config.defaultHeaders?.['x-app-name']).toBeUndefined();
+  });
+});

package/src/services/config.ts

@@ -3,6 +3,7 @@ import type { ApiConfig } from '@reservamos/js-api-client/core';
 type AvailableEnvironments = 'sandbox' | 'prod';
 
 let environment: AvailableEnvironments | undefined;
+let appName: string | undefined;
 const origin = window.location.origin;
 
 type CoreAPIConfig = Record<AvailableEnvironments, ApiConfig>;
@@ -28,6 +29,10 @@ function setEnvironment(env: AvailableEnvironments) {
   environment = env;
 }
 
+function setAppName(name: string) {
+  appName = name;
+}
+
 /**
  * Returns the core API config for the current environment.
  * @throws {Error} Throws an error if the environment is not set.
@@ -38,11 +43,21 @@ function getCoreAPIConfig(): ApiConfig {
       'Unable to get core API config, environment not set. Use configService.setEnvironment(environment) to set the environment.',
     );
   }
-  return coreAPIConfig[environment];
+
+  const config = coreAPIConfig[environment];
+
+  return {
+    ...config,
+    defaultHeaders: {
+      ...config.defaultHeaders,
+      ...(appName ? { 'x-app-name': appName } : {}),
+    },
+  };
 }
 
 const configService = {
   setEnvironment,
+  setAppName,
   getCoreAPIConfig,
 };
 

package/src/services/validator/validator.test.ts

@@ -1,6 +1,39 @@
 import { describe, expect, it } from 'vitest';
 import { customEventSchema } from '@/events/customEvent';
-import validatorService, { eventSchemas } from './validator';
+import validatorService, { eventSchemas, InitConfigSchema } from './validator';
+
+describe('InitConfigSchema', () => {
+  const validConfig = {
+    mixpanelToken: 'token',
+    identificationKey: 'key',
+    appName: 'reservamos-web',
+  };
+
+  it('accepts config without appName', () => {
+    expect(
+      InitConfigSchema.parse({
+        mixpanelToken: 'token',
+        identificationKey: 'key',
+      }),
+    ).toEqual({
+      mixpanelToken: 'token',
+      identificationKey: 'key',
+    });
+  });
+
+  it('rejects empty appName', () => {
+    expect(() =>
+      InitConfigSchema.parse({
+        ...validConfig,
+        appName: '',
+      }),
+    ).toThrow();
+  });
+
+  it('accepts valid appName', () => {
+    expect(InitConfigSchema.parse(validConfig)).toEqual(validConfig);
+  });
+});
 
 describe('parseEventProps', () => {
   /**

package/src/services/validator/validator.ts

@@ -39,6 +39,11 @@ const InitConfigSchema = z.object({
    * Optional proxy URL for identify requests.
    */
   identifyProxyUrl: z.string().optional(),
+  /**
+   * Optional client platform identifier sent as the `x-app-name` header on Datalake
+   * identify and anonymous-profile requests.
+   */
+  appName: z.string().min(1, 'App name cannot be empty').optional(),
 });
 
 interface CustomError {