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

package/package.json

@@ -1,23 +1,19 @@
 {
   "name": "@reservamos/browser-analytics",
-  "version": "1.1.6",
+  "version": "1.1.7-alpha.0",
   "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/services/fingerprint.test.ts

@@ -0,0 +1,147 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import fingerprintService from './fingerprint';
+
+const { initMock, getVisitorDataMock } = vi.hoisted(() => ({
+  initMock: vi.fn(),
+  getVisitorDataMock: vi.fn(),
+}));
+
+vi.mock('@fingerprintjs/fingerprintjs-pro-spa', () => ({
+  FingerprintJSPro: {
+    defaultEndpoint: 'https://fpjscdn.net',
+    defaultScriptUrlPattern: 'https://fpjscdn.net/agent',
+  },
+  FpjsClient: vi.fn().mockImplementation(() => ({
+    init: initMock,
+    getVisitorData: getVisitorDataMock,
+  })),
+}));
+
+describe('fingerprintService readiness', () => {
+  beforeEach(() => {
+    localStorage.clear();
+    initMock.mockReset();
+    getVisitorDataMock.mockReset();
+  });
+
+  it('does not identify with a client whose agent failed to load', async () => {
+    const initError = new Error('Agent script blocked');
+    const consoleError = vi
+      .spyOn(console, 'error')
+      .mockImplementation(() => undefined);
+    initMock.mockRejectedValue(initError);
+    getVisitorDataMock.mockRejectedValue(
+      new Error(
+        "FPJSAgent hasn't loaded yet. Make sure to call the init() method first.",
+      ),
+    );
+
+    await expect(
+      fingerprintService.initFingerprint('test-key'),
+    ).rejects.toThrow('Agent script blocked');
+    expect(fingerprintService.isFingerprintReady()).toBe(false);
+    await expect(fingerprintService.getFingerprint()).resolves.toBe('');
+    expect(getVisitorDataMock).not.toHaveBeenCalled();
+    expect(consoleError).toHaveBeenCalledWith(
+      'Error initializing identification service:',
+      initError,
+    );
+
+    consoleError.mockRestore();
+  });
+
+  it('identifies after the agent loads successfully', async () => {
+    initMock.mockResolvedValue(undefined);
+    getVisitorDataMock.mockResolvedValue({ visitorId: 'visitor-123' });
+
+    await fingerprintService.initFingerprint('test-key');
+
+    expect(fingerprintService.isFingerprintReady()).toBe(true);
+    await expect(fingerprintService.getFingerprint()).resolves.toBe(
+      'visitor-123',
+    );
+    expect(getVisitorDataMock).toHaveBeenCalledOnce();
+  });
+
+  it('waits for the agent to load before identifying', async () => {
+    let finishInit: () => void = () => undefined;
+    initMock.mockImplementation(
+      () =>
+        new Promise<void>((resolve) => {
+          finishInit = resolve;
+        }),
+    );
+    getVisitorDataMock.mockResolvedValue({ visitorId: 'visitor-123' });
+
+    const init = fingerprintService.initFingerprint('test-key');
+
+    expect(fingerprintService.isFingerprintReady()).toBe(false);
+    await expect(fingerprintService.getFingerprint()).resolves.toBe('');
+    expect(getVisitorDataMock).not.toHaveBeenCalled();
+
+    finishInit();
+    await init;
+
+    expect(fingerprintService.isFingerprintReady()).toBe(true);
+    await expect(fingerprintService.getFingerprint()).resolves.toBe(
+      'visitor-123',
+    );
+    expect(getVisitorDataMock).toHaveBeenCalledOnce();
+  });
+
+  it('does not mark a newer failed client ready when an older init finishes', async () => {
+    let finishFirstInit: () => void = () => undefined;
+    initMock
+      .mockImplementationOnce(
+        () =>
+          new Promise<void>((resolve) => {
+            finishFirstInit = resolve;
+          }),
+      )
+      .mockRejectedValueOnce(new Error('New agent script blocked'));
+    const consoleError = vi
+      .spyOn(console, 'error')
+      .mockImplementation(() => undefined);
+
+    const firstInit = fingerprintService.initFingerprint('first-key');
+    await expect(
+      fingerprintService.initFingerprint('second-key'),
+    ).rejects.toThrow('New agent script blocked');
+    finishFirstInit();
+    await firstInit;
+
+    expect(fingerprintService.isFingerprintReady()).toBe(false);
+    await expect(fingerprintService.getFingerprint()).resolves.toBe('');
+    expect(getVisitorDataMock).not.toHaveBeenCalled();
+
+    consoleError.mockRestore();
+  });
+
+  it('keeps a newer loaded client ready when an older init fails', async () => {
+    let failFirstInit: (reason?: unknown) => void = () => undefined;
+    initMock
+      .mockImplementationOnce(
+        () =>
+          new Promise<void>((_resolve, reject) => {
+            failFirstInit = reject;
+          }),
+      )
+      .mockResolvedValueOnce(undefined);
+    getVisitorDataMock.mockResolvedValue({ visitorId: 'new-visitor' });
+    const consoleError = vi
+      .spyOn(console, 'error')
+      .mockImplementation(() => undefined);
+
+    const firstInit = fingerprintService.initFingerprint('first-key');
+    await fingerprintService.initFingerprint('second-key');
+    failFirstInit(new Error('Old agent script blocked'));
+    await expect(firstInit).rejects.toThrow('Old agent script blocked');
+
+    expect(fingerprintService.isFingerprintReady()).toBe(true);
+    await expect(fingerprintService.getFingerprint()).resolves.toBe(
+      'new-visitor',
+    );
+
+    consoleError.mockRestore();
+  });
+});

package/src/services/fingerprint.ts

@@ -18,6 +18,7 @@ const DEFAULT_CACHE_NAME = 'default_fingerprint_cache';
 const DEFAULT_CACHE_TIME_IN_DAYS = 7;
 const PROXY_QUERY_PARAM =
   'apiKey=<apiKey>&version=<version>&loaderVersion=<loaderVersion>';
+let fingerprintAgentReady = false;
 
 /**
  * Calculates the expiration date based on the cache time.
@@ -102,18 +103,26 @@ async function initFingerprint(
     customScriptEndpointArray.unshift(buildProxyUrl(proxyUrl));
   }
 
+  fingerprintAgentReady = false;
   window.fingerprintConfig = {};
-  window.fpClient = new FpjsClient({
+  const client = new FpjsClient({
     loadOptions: {
       apiKey,
       endpoint: customEndpointArray,
       scriptUrlPattern: customScriptEndpointArray,
     },
   });
+  window.fpClient = client;
 
   try {
-    await window.fpClient.init();
+    await client.init();
+    if (window.fpClient === client) {
+      fingerprintAgentReady = true;
+    }
   } catch (error) {
+    if (window.fpClient === client) {
+      fingerprintAgentReady = false;
+    }
     console.error('Error initializing identification service:', error);
     throw error;
   }
@@ -122,8 +131,8 @@ async function initFingerprint(
 /**
  * Retrieves the fingerprint, first checking the cache and then querying the identification service if not found.
  * @param {boolean} cacheOnly - Optional flag to retrieve the fingerprint only from the cache.
- * @returns {Promise<string>} A promise that resolves with the fingerprint.
- * @throws {Error} Throws an error if retrieval fails.
+ * @returns {Promise<string>} A promise that resolves with the fingerprint, or an empty string when the agent is unavailable.
+ * @throws {Error} Throws an error if retrieval fails after the agent has loaded.
  */
 async function getFingerprint(cacheOnly = false): Promise<string> {
   if (!window.fingerprintConfig) {
@@ -139,14 +148,10 @@ async function getFingerprint(cacheOnly = false): Promise<string> {
     return cachedFingerprint;
   }
 
-  if (cacheOnly) {
+  if (cacheOnly || !isFingerprintReady()) {
     return '';
   }
 
-  if (!isFingerprintReady()) {
-    throw new Error('Identification service is not initialized.');
-  }
-
   try {
     const fpClient = window.fpClient;
     const { visitorId: fingerprint } = await fpClient.getVisitorData();
@@ -161,12 +166,11 @@ async function getFingerprint(cacheOnly = false): Promise<string> {
 /**
  * Checks if the identification service is ready.
  *
- * This function verifies whether the identification service has been initialized
- * and is ready to use by checking if the `fpClient` instance exists on the window object.
- * @returns {boolean} Returns true if the identification service is ready, otherwise false.
+ * This function verifies that the Fingerprint agent loaded successfully.
+ * @returns {boolean} Returns true only after the agent has loaded.
  */
 function isFingerprintReady(): boolean {
-  return window.fpClient !== undefined;
+  return window.fpClient !== undefined && fingerprintAgentReady;
 }
 
 const fingerprintService = {