@envive-ai/react-hooks 0.3.19-alpha-marlo-4 → 0.3.19-alpha-marlo-6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@envive-ai/react-hooks",
-  "version": "0.3.19-alpha-marlo-4",
+  "version": "0.3.19-alpha-marlo-6",
   "description": "React hooks for connecting to Envive AI services.",
   "keywords": [
     "react",

package/src/contexts/amplitudeContext/__tests__/amplitudeContext.test.tsx

@@ -332,7 +332,7 @@ describe('AmplitudeProvider - React Context Integration', () => {
       });
     });
 
-    it('should still render children when not ready', async () => {
+    it('should render children with isReady=false when amplitude key is missing', async () => {
       // Create a provider without required dependencies
       const IncompleteWrapper: React.FC<{ children: React.ReactNode }> = ({ children }) => {
         return (
@@ -357,13 +357,14 @@ describe('AmplitudeProvider - React Context Integration', () => {
 
       render(
         <IncompleteWrapper>
-          <div data-testid="should-render">Should render</div>
+          <MockAmplitudeComponent />
         </IncompleteWrapper>,
       );
 
-      // AmplitudeProvider always renders children, even when not ready
+      // AmplitudeProvider renders children even when not ready — isReady reflects tracking unavailability
       await waitFor(() => {
-        expect(screen.getByTestId('should-render')).toBeInTheDocument();
+        expect(screen.getByTestId('amplitude-component')).toBeInTheDocument();
+        expect(screen.getByTestId('is-ready').textContent).toBe('false');
       });
     });
   });
@@ -446,11 +447,15 @@ describe('AmplitudeProvider - React Context Integration', () => {
   });
 
   describe('useAmplitude hook', () => {
-    it('should return a no-op context when used outside provider', () => {
-      render(<MockAmplitudeComponent />);
+    it('should throw error when used outside provider', () => {
+      // Suppress console.error for this test
+      const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      expect(() => {
+        render(<MockAmplitudeComponent />);
+      }).toThrow('useAmplitude must be used within AmplitudeProvider');
 
-      expect(screen.getByTestId('amplitude-component')).toBeInTheDocument();
-      expect(screen.getByTestId('is-ready').textContent).toBe('false');
+      consoleError.mockRestore();
     });
 
     it('should provide amplitude context when used within provider', async () => {

package/src/contexts/amplitudeContext/amplitudeContext.tsx

@@ -26,13 +26,7 @@ interface AmplitudeContextType {
   setSupplementalDefaultProps: (props: Record<string, unknown>) => void;
 }
 
-const noOpAmplitudeContext: AmplitudeContextType = {
-  trackEvent: async () => {},
-  isReady: false,
-  setSupplementalDefaultProps: () => {},
-};
-
-const AmplitudeContext = createContext<AmplitudeContextType>(noOpAmplitudeContext);
+const AmplitudeContext = createContext<AmplitudeContextType | null>(null);
 
 export const AmplitudeProvider: React.FC<{
   externalAmplitudeService?: AmplitudeService;
@@ -124,13 +118,17 @@ export const AmplitudeProvider: React.FC<{
     [service, isReady],
   );
 
-  return (
-    <AmplitudeContext.Provider value={isReady ? value : noOpAmplitudeContext}>
-      {children}
-    </AmplitudeContext.Provider>
-  );
+  if (!isReady) {
+    return null;
+  }
+
+  return <AmplitudeContext.Provider value={value}>{children}</AmplitudeContext.Provider>;
 };
 
 export const useAmplitude = () => {
-  return useContext(AmplitudeContext);
+  const context = useContext(AmplitudeContext);
+  if (!context) {
+    throw new Error('useAmplitude must be used within AmplitudeProvider');
+  }
+  return context;
 };

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',
@@ -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

@@ -51,6 +51,8 @@ export class AmplitudeService {
 
   private config: AmplitudeServiceConfig;
 
+  private _isMockMode: boolean = false;
+
   constructor(config: AmplitudeServiceConfig) {
     this.config = config;
     this.initialize();
@@ -65,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);
@@ -213,8 +219,8 @@ export class AmplitudeService {
     return enrichment;
   }
 
-  static isDummyApiKey(apiKey: string): boolean {
-    return !/^[0-9a-f]{32}$/i.test(apiKey);
+  private static isValidAmplitudeApiKey(apiKey: string): boolean {
+    return /^[0-9a-f]{32}$/i.test(apiKey);
   }
 
   private initialize(): void {
@@ -232,8 +238,12 @@ export class AmplitudeService {
       return;
     }
 
-    if (AmplitudeService.isDummyApiKey(this.config.amplitudeApiKey)) {
-      logger.logDebug('AmplitudeService is using a dummy API key — analytics will not be tracked');
+    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;
     }