@envive-ai/react-hooks 0.3.18 → 0.3.19-alpha-marlo-1

package/src/hooks/WidgetInteraction/useWidgetInteraction.ts

@@ -6,12 +6,15 @@ import { v4 as uuid } from 'uuid';
 import { InternalWidgetInteraction, WidgetInteraction } from './types';
 import { extractPageContext } from './utils';
 
+const getInteractionId = () => uuid();
+
 export const useWidgetInteraction = () => {
   const { trackEvent } = useAmplitude();
   const variantInfo = useAtomValue(pageVariantInfoAtom);
 
   const trackWidgetInteraction = (props: WidgetInteraction) => {
     if (props.trigger) {
+      // eslint-disable-next-line no-param-reassign
       props.trigger.interaction_id = props.trigger.interaction_id || getInteractionId();
     }
 
@@ -26,8 +29,6 @@ export const useWidgetInteraction = () => {
     });
   };
 
-  const getInteractionId = () => uuid();
-
   return {
     trackWidgetInteraction,
     getInteractionId,

package/src/hooks/WidgetInteraction/utils.ts

@@ -3,9 +3,9 @@ import {
   FullPageSalesAgentVariantInfo,
   HomeVariantInfo,
   OtherVariantInfo,
-  PageVariantInfo,
   PDPPageVariantInfo,
   PLPPageVariantInfo,
+  PageVariantInfo,
 } from '../../contexts/pageContext/types';
 import { WidgetInteractionContext, WidgetInteractionPageType } from './types';
 
@@ -38,6 +38,8 @@ export const extractPageContext = (
         page_id: (pageVariant as FullPageSalesAgentVariantInfo).url,
         page_type: WidgetInteractionPageType.FULL_PAGE,
       };
+    default:
+      return null;
   }
 
   return null;

package/src/services/amplitudeService/__tests__/amplitudeService.test.ts

@@ -85,10 +85,12 @@ describe('AmplitudeService', () => {
     });
   });
 
+  const validApiKey = 'abcdef1234567890abcdef1234567890';
+
   const createService = (overrides?: Partial<AmplitudeServiceConfig>) => {
     return new AmplitudeService({
       userId: 'test-user-id',
-      amplitudeApiKey: 'test-api-key',
+      amplitudeApiKey: validApiKey,
       dataResidency: 'US',
       env: 'test',
       orgId: 'test-org-id',
@@ -107,7 +109,7 @@ describe('AmplitudeService', () => {
       createService();
 
       expect(mockInit).toHaveBeenCalledWith(
-        'test-api-key',
+        validApiKey,
         'test-user-id',
         expect.objectContaining({
           serverZone: 'US',
@@ -121,7 +123,7 @@ describe('AmplitudeService', () => {
     it('should not be ready if userId is missing', () => {
       const service = new AmplitudeService({
         userId: '',
-        amplitudeApiKey: 'test-api-key',
+        amplitudeApiKey: validApiKey,
         dataResidency: 'US',
         env: 'test',
         orgId: 'test-org-id',
@@ -157,7 +159,7 @@ describe('AmplitudeService', () => {
     it('should not be ready if featureFlagService is missing', () => {
       const service = new AmplitudeService({
         userId: 'test-user-id',
-        amplitudeApiKey: 'test-api-key',
+        amplitudeApiKey: validApiKey,
         dataResidency: 'US',
         env: 'test',
         orgId: 'test-org-id',
@@ -177,6 +179,54 @@ describe('AmplitudeService', () => {
 
       expect(service.isReady).toBe(true);
     });
+
+    it('should not set isMockMode when all required config is provided', () => {
+      const service = createService();
+
+      expect(service.isMockMode).toBe(false);
+    });
+  });
+
+  describe('Mock mode', () => {
+    it('should set isMockMode and not initialize the client when API key is not a valid hex string', () => {
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+      const service = createService({ amplitudeApiKey: 'not-a-valid-key' });
+
+      expect(service.isReady).toBe(false);
+      expect(service.isMockMode).toBe(true);
+      expect(mockInit).not.toHaveBeenCalled();
+
+      consoleSpy.mockRestore();
+    });
+
+    it('should print a console.log message when a mock API key is detected', () => {
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+      createService({ amplitudeApiKey: 'not-a-valid-key' });
+
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Mock API key detected'));
+
+      consoleSpy.mockRestore();
+    });
+
+    it('should not set isMockMode when API key is empty — service is simply not ready', () => {
+      const service = createService({ amplitudeApiKey: '' });
+
+      expect(service.isReady).toBe(false);
+      expect(service.isMockMode).toBe(false);
+    });
+
+    it('should not call the Amplitude client when trackEvent is called in mock mode', async () => {
+      const service = createService({ amplitudeApiKey: 'not-a-valid-key' });
+
+      await service.trackEvent({
+        eventName: SpiffyMetricsEventName.ChatUserMessageInput,
+        eventProps: { message: 'test' },
+      });
+
+      expect(mockTrack).not.toHaveBeenCalled();
+    });
   });
 
   describe('trackEvent', () => {
@@ -269,7 +319,7 @@ describe('AmplitudeService', () => {
     it('should not track if client is not initialized', async () => {
       const service = new AmplitudeService({
         userId: '',
-        amplitudeApiKey: 'test-api-key',
+        amplitudeApiKey: validApiKey,
         dataResidency: 'US',
         env: 'test',
         orgId: 'test-org-id',
@@ -281,7 +331,7 @@ describe('AmplitudeService', () => {
         featureFlagService,
       });
 
-      const logWarnSpy = vi.spyOn(Logger, 'logWarn');
+      const logWarnSpy = vi.spyOn(Logger.prototype, 'logWarn');
 
       await service.trackEvent({
         eventName: SpiffyMetricsEventName.ChatUserMessageInput,
@@ -304,7 +354,7 @@ describe('AmplitudeService', () => {
         throw error;
       });
 
-      const logErrorSpy = vi.spyOn(Logger, 'logError');
+      const logErrorSpy = vi.spyOn(Logger.prototype, 'logError');
 
       await service.trackEvent({
         eventName: SpiffyMetricsEventName.ChatUserMessageInput,
@@ -312,7 +362,7 @@ describe('AmplitudeService', () => {
       });
 
       expect(logErrorSpy).toHaveBeenCalledWith(
-        '[spiffy-ai] Error tracking event',
+        'Error tracking event',
         error,
         expect.objectContaining({
           eventName: SpiffyMetricsEventName.ChatUserMessageInput,
@@ -419,7 +469,7 @@ describe('AmplitudeService', () => {
     it('should fall back to window.localStorage when getLocalStorageItem is not provided', async () => {
       const service = new AmplitudeService({
         userId: 'test-user-id',
-        amplitudeApiKey: 'test-api-key',
+        amplitudeApiKey: validApiKey,
         dataResidency: 'US',
         env: 'test',
         orgId: 'test-org-id',

package/src/services/amplitudeService/amplitudeService.ts

@@ -17,6 +17,8 @@ import { EnviveMetricsEventName, SpiffyMetricsEventName } from './eventNames';
 // Re-export event names for convenience
 export { EnviveMetricsEventName, SpiffyMetricsEventName };
 
+const logger = new Logger('amplitudeService');
+
 export interface TrackEventParams {
   eventName: SpiffyMetricsEventName | EnviveMetricsEventName;
   eventProps?: Record<string, unknown>;
@@ -49,6 +51,8 @@ export class AmplitudeService {
 
   private config: AmplitudeServiceConfig;
 
+  private _isMockMode: boolean = false;
+
   constructor(config: AmplitudeServiceConfig) {
     this.config = config;
     this.initialize();
@@ -63,6 +67,10 @@ export class AmplitudeService {
     );
   }
 
+  get isMockMode(): boolean {
+    return this._isMockMode;
+  }
+
   private getLocalStorageItem(key: string): string | null {
     if (this.config.getLocalStorageItem) {
       return this.config.getLocalStorageItem(key);
@@ -211,13 +219,17 @@ export class AmplitudeService {
     return enrichment;
   }
 
+  private static isValidAmplitudeApiKey(apiKey: string): boolean {
+    return /^[0-9a-f]{32}$/i.test(apiKey);
+  }
+
   private initialize(): void {
     const isReady = Boolean(
       this.config.userId && this.config.featureFlagService && this.config.amplitudeApiKey,
     );
 
     if (!isReady) {
-      Logger.logDebug('AmplitudeService is not ready', {
+      logger.logDebug('AmplitudeService is not ready', {
         isReady,
         userId: this.config.userId,
         hasFeatureFlagService: !!this.config.featureFlagService,
@@ -226,6 +238,15 @@ export class AmplitudeService {
       return;
     }
 
+    if (!AmplitudeService.isValidAmplitudeApiKey(this.config.amplitudeApiKey)) {
+      this._isMockMode = true;
+      // eslint-disable-next-line no-console
+      console.log(
+        '[AmplitudeService] Mock API key detected — running in mock mode, no events will be sent to Amplitude.',
+      );
+      return;
+    }
+
     if (!this.amplitudeClient) {
       const currentAmplitudeInstance: BrowserClient = createInstance();
 
@@ -351,12 +372,12 @@ export class AmplitudeService {
     eventGroups,
     alsoSendToGoogleAnalytics = false,
   }: TrackEventParams): Promise<void> {
-    Logger.logDebug('Submitting event', eventName);
+    logger.logDebug('Submitting event', eventName);
     try {
       const decoratedEventName = AmplitudeService.decorateEventName(eventName);
 
       if (!this.amplitudeClient) {
-        Logger.logWarn('amplitude client undefined', undefined, {
+        logger.logWarn('amplitude client undefined', undefined, {
           event_name: decoratedEventName,
         });
         return;
@@ -377,7 +398,7 @@ export class AmplitudeService {
       const hashArray = Array.from(new Uint8Array(hashBuffer));
       const currentInsertId = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
 
-      Logger.logDebug(`amplitude tracking ${decoratedEventName}`, null, {
+      logger.logDebug(`amplitude tracking ${decoratedEventName}`, null, {
         event_name: decoratedEventName,
         props: mappedEventProps,
       });
@@ -404,7 +425,7 @@ export class AmplitudeService {
         };
         projectToGA4(eventName as EnviveMetricsEventName, mergedPropsForGA4);
       } else if (alsoSendToGoogleAnalytics && this.config.orgGaConfig) {
-        Logger.logDebug('[spiffy-ai] GA tracking', decoratedEventName);
+        logger.logDebug('GA tracking', decoratedEventName);
         if (typeof window !== 'undefined' && window.dataLayer) {
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
           (window.dataLayer as any[]).push({
@@ -414,7 +435,7 @@ export class AmplitudeService {
         }
       }
     } catch (err) {
-      Logger.logError('[spiffy-ai] Error tracking event', err, {
+      logger.logError('Error tracking event', err, {
         eventName,
         eventProps,
       });

package/src/services/ga4ProjectionService/ga4ProjectionService.ts

@@ -2,6 +2,8 @@ import Logger from 'src/application/logging/logger';
 import { EnviveMetricsEventName } from '../amplitudeService/eventNames';
 import { GA4ProjectedEventConfig, GA4_EVENT_SCHEMA } from './ga4EventSchema';
 
+const logger = new Logger('ga4ProjectionService');
+
 const filterToSchema = (
   eventProps: Record<string, unknown>,
   allowedFields: readonly string[],
@@ -130,7 +132,7 @@ export const projectToGA4 = (
       ...truncatedParams,
     });
   } catch (err) {
-    Logger.logError('[envive-ai] Error projecting event to GA4', err, {
+    logger.logError('Error projecting event to GA4', err, {
       eventName,
     });
   }

package/src/services/userIdentityService/userIdentityService.ts

@@ -4,6 +4,8 @@ import { getAtomStore } from 'src/atoms/atomStore';
 import { userIdAtom } from 'src/atoms/app';
 import { ExecutionContext } from '@envive-ai/analytics/dist/analytics/EnviveAnalytics';
 
+const logger = new Logger('userIdentityService');
+
 type UserIdentityServiceProps = {
   apiKey: string;
 };
@@ -18,7 +20,7 @@ export class UserIdentityService {
   }
 
   getUserIdOverrideFromLocalStorage(): string | undefined {
-    Logger.logDebug('[spiffy-ai] Getting userID from localStorage');
+    logger.logDebug('Getting userID from localStorage');
     return localStorage.getItem(this.USER_ID_OVERRIDE_KEY) ?? undefined;
   }
 
@@ -29,7 +31,7 @@ export class UserIdentityService {
     }
 
     try {
-      Logger.logDebug('Getting userID via EnviveAnalytics in UserIdentityService');
+      logger.logDebug('Getting userID via EnviveAnalytics in UserIdentityService');
       const enviveAnalytics = new EnviveAnalytics({
         apiKey: this.apiKey,
         environmentInfo: { executionContext: ExecutionContext.EnviveReactComponentsV3 },
@@ -37,16 +39,14 @@ export class UserIdentityService {
       const enviveUserId = await enviveAnalytics.resolveEnviveUserId();
 
       if (!enviveUserId) {
-        throw new Error(
-          '[spiffy-ai] EnviveAnalytics.resolveEnviveUserId() returned null/undefined',
-        );
+        throw new Error('EnviveAnalytics.resolveEnviveUserId() returned null/undefined');
       }
 
       return enviveUserId;
     } catch (error: unknown) {
-      Logger.logError('[spiffy-ai] CRITICAL: Failed to get user ID:', error);
+      logger.logError('CRITICAL: Failed to get user ID:', error);
       const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-      throw new Error(`[spiffy-ai] CRITICAL: User ID resolution failed: ${errorMessage}`);
+      throw new Error(`CRITICAL: User ID resolution failed: ${errorMessage}`);
     }
   }
 
@@ -57,7 +57,7 @@ export class UserIdentityService {
       const store = atomStore || getAtomStore();
       store.set(userIdAtom, userId);
     } catch (error) {
-      Logger.logError('[spiffy-ai] CRITICAL: Failed to initialize user ID:', error);
+      logger.logError('CRITICAL: Failed to initialize user ID:', error);
       throw error;
     }
   }