@envive-ai/react-hooks 0.3.56 → 0.3.57

package/src/application/commerce-api.ts

@@ -263,34 +263,24 @@ class CommerceApiClient {
         const reader = response.raw.body.getReader();
         const decoder = new TextDecoder('utf-8');
 
+        // Buffer holding the trailing incomplete line of the previous chunk
         let partial = '';
-        // TODO this function is recreated every time new data comes from the stream - define it outside of the generator
+
         const safeParse = (line: string): unknown => {
           try {
             return JSON.parse(line); // Parse the JSON string
           } catch (err) {
-            logger.logError('Error parsing streamed line', err, {
-              line,
-              partial,
-            });
-            // swallow the error and set the partial to our current chunk
-            partial = line;
-            return partial;
+            logger.logError('Error parsing streamed line', err, { line });
+            return null;
           }
         };
 
-        // TODO this function is recreated every time new data comes from the stream - define it outside of the generator
-        const processChunk = (chunk: string): unknown[] => {
-          // merge the partial with the incoming chunk
-          const lines = `${partial}${chunk}`.split('\n');
-
-          const parsedLines = lines
+        const parseLines = (lines: string[]): unknown[] =>
+          lines
             .map(line => line.replace(/^data: /, '').trim()) // Remove the "data: " prefix
             .filter(line => line !== '' && line !== '[DONE]') // Remove empty lines and "[DONE]"
             .map(safeParse)
-            .filter(v => v); // and filter out the undefined values
-          return parsedLines;
-        };
+            .filter(v => v != null);
 
         while (true) {
           // eslint-disable-next-line no-await-in-loop
@@ -300,11 +290,12 @@ class CommerceApiClient {
             break;
           }
 
-          // Massage and parse the chunk of data
-          const chunk = decoder.decode(value);
-          const parsedLines = processChunk(chunk);
+          // A chunk boundary can fall mid-line, so only parse the lines that
+          // are terminated by a newline and hold the rest until the next chunk
+          const lines = `${partial}${decoder.decode(value, { stream: true })}`.split('\n');
+          partial = lines.pop() ?? '';
 
-          for (const parsedLine of parsedLines) {
+          for (const parsedLine of parseLines(lines)) {
             const validatedResponse = validateResponse(parsedLine);
 
             if (validatedResponse) {
@@ -312,6 +303,15 @@ class CommerceApiClient {
             }
           }
         }
+
+        // Flush the remainder of a stream that didn't end with a newline
+        for (const parsedLine of parseLines([`${partial}${decoder.decode()}`])) {
+          const validatedResponse = validateResponse(parsedLine);
+
+          if (validatedResponse) {
+            yield validatedResponse;
+          }
+        }
       } catch (error: unknown) {
         logger.logError('Failed to get next streaming responses', error, {
           payloadContext: payload?.context,

package/src/application/logging/__tests__/logger.test.ts

@@ -0,0 +1,159 @@
+import Logger from 'src/application/logging/logger';
+import {
+  DEFAULT_LOG_LEVEL,
+  LOG_LEVEL_STORAGE_KEY,
+  getLogLevel,
+  isLevelEnabled,
+  resetLogLevelForTesting,
+  setLogLevel,
+} from 'src/application/logging/logLevel';
+
+const setHref = (href: string) => {
+  Object.defineProperty(window, 'location', {
+    configurable: true,
+    value: { ...window.location, href, search: new URL(href).search },
+  });
+};
+
+describe('logger log level', () => {
+  const originalHref = window.location.href;
+  let spies: ReturnType<typeof vi.spyOn>[] = [];
+  let logger: Logger;
+
+  beforeEach(() => {
+    resetLogLevelForTesting();
+    window.localStorage.clear();
+    setHref('https://merchant.example.com/products/thing');
+    delete (window as { _envive?: unknown })._envive;
+    delete (window as { _spiffy?: unknown })._spiffy;
+    logger = new Logger('testCaller');
+    spies = [
+      vi.spyOn(console, 'debug').mockImplementation(() => {}),
+      vi.spyOn(console, 'info').mockImplementation(() => {}),
+      vi.spyOn(console, 'warn').mockImplementation(() => {}),
+      vi.spyOn(console, 'error').mockImplementation(() => {}),
+    ];
+  });
+
+  afterEach(() => {
+    spies.forEach(spy => spy.mockRestore());
+    resetLogLevelForTesting();
+    setHref(originalHref);
+  });
+
+  const emitAll = () => {
+    logger.logDebug('d');
+    logger.logInfo('i');
+    logger.logWarn('w', undefined);
+    logger.logError('e', undefined);
+  };
+
+  const emitted = () => ({
+    debug: (console.debug as unknown as { mock: { calls: unknown[] } }).mock.calls.length,
+    info: (console.info as unknown as { mock: { calls: unknown[] } }).mock.calls.length,
+    warn: (console.warn as unknown as { mock: { calls: unknown[] } }).mock.calls.length,
+    error: (console.error as unknown as { mock: { calls: unknown[] } }).mock.calls.length,
+  });
+
+  it('mutes debug and info but keeps warn and error by default', () => {
+    expect(DEFAULT_LOG_LEVEL).toBe('warn');
+    expect(getLogLevel()).toBe('warn');
+
+    emitAll();
+
+    expect(emitted()).toEqual({ debug: 0, info: 0, warn: 1, error: 1 });
+  });
+
+  it('silences every level at "silent"', () => {
+    setLogLevel('silent');
+
+    emitAll();
+
+    expect(emitted()).toEqual({ debug: 0, info: 0, warn: 0, error: 0 });
+  });
+
+  it('emits every level at "debug"', () => {
+    setLogLevel('debug');
+
+    emitAll();
+
+    expect(emitted()).toEqual({ debug: 1, info: 1, warn: 1, error: 1 });
+  });
+
+  it('keeps the existing output format when a level is enabled', () => {
+    setLogLevel('debug');
+
+    logger.logDebug('a message', { extra: true });
+
+    expect(console.debug).toHaveBeenCalledWith(
+      expect.stringMatching(/^DEBUG: \[envive-ai\] .+ - testCaller - a message$/),
+      { extra: true },
+    );
+  });
+
+  it('honours the window override without a reload', () => {
+    expect(isLevelEnabled('debug')).toBe(false);
+
+    (window as { _envive?: { logLevel?: string } })._envive = { logLevel: 'debug' };
+
+    expect(isLevelEnabled('debug')).toBe(true);
+    expect(getLogLevel()).toBe('debug');
+  });
+
+  it('accepts the _spiffy window override and is case-insensitive', () => {
+    (window as { _spiffy?: { logLevel?: string } })._spiffy = { logLevel: 'DEBUG' };
+
+    expect(getLogLevel()).toBe('debug');
+  });
+
+  it('ignores an unrecognised level and falls back to the default', () => {
+    (window as { _envive?: { logLevel?: string } })._envive = { logLevel: 'chatty' };
+
+    expect(getLogLevel()).toBe(DEFAULT_LOG_LEVEL);
+  });
+
+  it('reads the level from the query param and persists it for later navigations', () => {
+    setHref('https://merchant.example.com/products/thing?envive_log_level=debug');
+
+    expect(getLogLevel()).toBe('debug');
+    expect(window.localStorage.getItem(LOG_LEVEL_STORAGE_KEY)).toBe('debug');
+  });
+
+  it('applies a persisted level on a page without the query param', () => {
+    window.localStorage.setItem(LOG_LEVEL_STORAGE_KEY, 'info');
+
+    expect(getLogLevel()).toBe('info');
+  });
+
+  it('lets the query param win over a level pinned programmatically', () => {
+    setHref('https://merchant.example.com/products/thing?envive_log_level=debug');
+    setLogLevel('silent');
+
+    expect(getLogLevel()).toBe('debug');
+  });
+
+  it('lets setLogLevel(undefined) fall back to the levers below it', () => {
+    window.localStorage.setItem(LOG_LEVEL_STORAGE_KEY, 'info');
+    setLogLevel('silent');
+    expect(getLogLevel()).toBe('silent');
+
+    setLogLevel(undefined);
+
+    expect(getLogLevel()).toBe('info');
+  });
+
+  it('survives localStorage throwing', () => {
+    const getItem = vi.spyOn(window.localStorage, 'getItem').mockImplementation(() => {
+      throw new Error('blocked');
+    });
+    const setItem = vi.spyOn(window.localStorage, 'setItem').mockImplementation(() => {
+      throw new Error('blocked');
+    });
+    setHref('https://merchant.example.com/products/thing?envive_log_level=debug');
+
+    expect(getLogLevel()).toBe('debug');
+
+    getItem.mockRestore();
+    setItem.mockRestore();
+  });
+});

package/src/application/logging/index.ts

@@ -0,0 +1,12 @@
+export { default } from 'src/application/logging/logger';
+export {
+  DEFAULT_LOG_LEVEL,
+  getLogLevel,
+  isLevelEnabled,
+  LOG_LEVEL_QUERY_PARAM,
+  LOG_LEVEL_STORAGE_KEY,
+  LOG_LEVELS,
+  resetLogLevelForTesting,
+  setLogLevel,
+} from 'src/application/logging/logLevel';
+export type { LogLevel } from 'src/application/logging/logLevel';

package/src/application/logging/logLevel.ts

@@ -0,0 +1,162 @@
+/**
+ * Console log-level gate shared by every package's Logger.
+ *
+ * Debug and info are muted by default: a single merchant page load produces
+ * ~950 debug lines (the bulk of them from featureFlagService checking gates on
+ * every render), which is unusable noise on a customer's site.
+ *
+ * To turn logging back on, in priority order:
+ *
+ *   1. Query param — `?envive_log_level=debug`
+ *      The support lever. Wins over everything else so logging can always be
+ *      re-enabled on a live merchant page, even if the embedding page pinned a
+ *      level at bootstrap. The chosen level is persisted to localStorage so it
+ *      survives navigation (a support session spans more than one page view);
+ *      clear it with `?envive_log_level=warn` or by removing the stored key.
+ *
+ *   2. `setLogLevel('debug')` — programmatic, e.g. bootstrap code or tests.
+ *
+ *   3. `window._envive.logLevel = 'debug'` (or `window._spiffy.logLevel`)
+ *      Read on every call, so it can be flipped from the browser console
+ *      mid-session without a reload.
+ *
+ *   4. `localStorage['envive-log-level']` — sticky per browser.
+ *
+ *   5. Default: 'warn'.
+ *
+ * Levels, least to most verbose: silent < error < warn < info < debug.
+ * A message emits when its own level is at or below the resolved level, so
+ * 'silent' mutes everything including errors.
+ *
+ * Kept free of React imports (like featureFlagService): the injection bundle
+ * logs from its pre-config code path, before it decides whether to load the
+ * React app, and pulling React in here would put it on the eager chunk.
+ */
+
+export const LOG_LEVELS = ['silent', 'error', 'warn', 'info', 'debug'] as const;
+
+export type LogLevel = (typeof LOG_LEVELS)[number];
+
+const LEVEL_SEVERITY: Record<LogLevel, number> = {
+  silent: 0,
+  error: 1,
+  warn: 2,
+  info: 3,
+  debug: 4,
+};
+
+/* Errors and warnings only. logDebug/logInfo make up the bulk of the call sites
+ * in this repo and used to print on every merchant page load. */
+export const DEFAULT_LOG_LEVEL: LogLevel = 'warn';
+
+export const LOG_LEVEL_QUERY_PARAM = 'envive_log_level';
+export const LOG_LEVEL_STORAGE_KEY = 'envive-log-level';
+
+const asLogLevel = (value: unknown): LogLevel | undefined => {
+  if (typeof value !== 'string') {
+    return undefined;
+  }
+  const normalized = value.toLowerCase();
+  return (LOG_LEVELS as readonly string[]).includes(normalized)
+    ? (normalized as LogLevel)
+    : undefined;
+};
+
+/* Set by setLogLevel(). Overrides window/stored/default, but deliberately not
+ * the query param, so support can always turn logging back on in a live session
+ * even if the embedding page pinned a level at bootstrap. */
+let programmaticLevel: LogLevel | undefined;
+
+/* The query param and localStorage cannot change without a navigation, so both
+ * are read once. `undefined` means "not resolved yet" and `null` caches a miss,
+ * keeping repeat lookups off the logging hot path. */
+let cachedQueryLevel: LogLevel | null | undefined;
+let cachedStoredLevel: LogLevel | null | undefined;
+
+/* Persists the level so it survives navigation — a support session spans more
+ * than one page view. */
+const storeLevel = (level: LogLevel): void => {
+  if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') {
+    return;
+  }
+  try {
+    window.localStorage.setItem(LOG_LEVEL_STORAGE_KEY, level);
+  } catch {
+    // Storage can be full or blocked; the level still applies to this page.
+  }
+};
+
+const readQueryLevel = (): LogLevel | undefined => {
+  if (typeof window === 'undefined') {
+    return undefined;
+  }
+  const url = window.location?.href ?? '';
+  if (!url.includes('?')) {
+    return undefined;
+  }
+  try {
+    const params = new URLSearchParams(new URL(url).search);
+    return asLogLevel(params.get(LOG_LEVEL_QUERY_PARAM));
+  } catch {
+    return undefined;
+  }
+};
+
+const queryLevel = (): LogLevel | undefined => {
+  if (cachedQueryLevel === undefined) {
+    const level = readQueryLevel();
+    if (level) {
+      storeLevel(level);
+    }
+    cachedQueryLevel = level ?? null;
+  }
+  return cachedQueryLevel ?? undefined;
+};
+
+const storedLevel = (): LogLevel | undefined => {
+  if (cachedStoredLevel === undefined) {
+    let level: LogLevel | undefined;
+    if (typeof window !== 'undefined' && typeof window.localStorage !== 'undefined') {
+      try {
+        level = asLogLevel(window.localStorage.getItem(LOG_LEVEL_STORAGE_KEY));
+      } catch {
+        level = undefined;
+      }
+    }
+    cachedStoredLevel = level ?? null;
+  }
+  return cachedStoredLevel ?? undefined;
+};
+
+/* Read on every call, so it can be flipped from the browser console mid-session
+ * without a reload. */
+const windowLevel = (): LogLevel | undefined => {
+  if (typeof window === 'undefined') {
+    return undefined;
+  }
+  const windowOverride = window as Window & {
+    _envive?: { logLevel?: string };
+    _spiffy?: { logLevel?: string };
+  };
+  return asLogLevel(windowOverride._envive?.logLevel ?? windowOverride._spiffy?.logLevel);
+};
+
+/* Resolution order mirrors featureFlagService's override chain: query param >
+ * setLogLevel() > window._envive.logLevel > localStorage > default. */
+export const getLogLevel = (): LogLevel =>
+  queryLevel() ?? programmaticLevel ?? windowLevel() ?? storedLevel() ?? DEFAULT_LOG_LEVEL;
+
+/* Pass undefined to clear the override and fall back to the levers above. */
+export const setLogLevel = (level: LogLevel | undefined): void => {
+  programmaticLevel = level;
+};
+
+export const isLevelEnabled = (level: Exclude<LogLevel, 'silent'>): boolean =>
+  LEVEL_SEVERITY[getLogLevel()] >= LEVEL_SEVERITY[level];
+
+/* Test seam: drops the memoized query-param and localStorage resolution. */
+export const resetLogLevelForTesting = (): void => {
+  programmaticLevel = undefined;
+  cachedQueryLevel = undefined;
+  cachedStoredLevel = undefined;
+};

package/src/application/logging/logger.ts

@@ -1,4 +1,5 @@
 /* eslint-disable no-console */
+import { isLevelEnabled } from 'src/application/logging/logLevel';
 
 class Logger {
   private readonly caller: string;
@@ -15,6 +16,9 @@ class Logger {
   }
 
   logInfo(message: string, ...args: unknown[]): void {
+    if (!isLevelEnabled('info')) {
+      return;
+    }
     console.info(
       `INFO: [envive-ai] ${Logger.getTimestamp()} - ${this.caller} - ${message}`,
       ...args,
@@ -22,6 +26,9 @@ class Logger {
   }
 
   logDebug(message: string, ...args: unknown[]): void {
+    if (!isLevelEnabled('debug')) {
+      return;
+    }
     console.debug(
       `DEBUG: [envive-ai] ${Logger.getTimestamp()} - ${this.caller} - ${message}`,
       ...args,
@@ -29,6 +36,9 @@ class Logger {
   }
 
   logError(message: string, error: unknown | undefined, ...args: unknown[]): void {
+    if (!isLevelEnabled('error')) {
+      return;
+    }
     console.error(
       `ERROR: [envive-ai] ${Logger.getTimestamp()} - ${this.caller} - ${message} error=${error}`,
       args,
@@ -36,6 +46,9 @@ class Logger {
   }
 
   logWarn(message: string, error: unknown | undefined, ...args: unknown[]): void {
+    if (!isLevelEnabled('warn')) {
+      return;
+    }
     console.warn(
       `WARN: [envive-ai] ${Logger.getTimestamp()} - ${this.caller} - ${message} error=${error}`,
       args,

package/src/contexts/salesAgentContext/salesAgentService.ts

@@ -313,7 +313,7 @@ export const useSalesAgentService: () => SalesAgentService = () => {
         //   },
         // });
       } catch (e) {
-        console.error('error getting streaming responses', e);
+        logger.logError('error getting streaming responses', e);
         successfulResponse = false;
         // Log failed next_responses call
         // const responseTime = Date.now() - startTime;

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

@@ -177,13 +177,12 @@ describe('UserIdentityProvider', () => {
     it('should allow components to access context via useUserIdentity hook', async () => {
       renderWithProviders(<MockComponent />);
 
+      // Verify all context methods are accessible. The user id is populated by an async
+      // effect, so the content assertions must wait for it rather than assert right away.
       await waitFor(() => {
-        expect(screen.getByTestId('user-id')).toBeInTheDocument();
+        expect(screen.getByTestId('user-id').textContent).toContain('spiffy-user-id-');
+        expect(screen.getByTestId('is-ready').textContent).toBe('true');
       });
-
-      // Verify all context methods are accessible
-      expect(screen.getByTestId('user-id').textContent).toContain('spiffy-user-id-');
-      expect(screen.getByTestId('is-ready').textContent).toBe('true');
     });
 
     it('should throw error when used outside of UserIdentityProvider', () => {