@memori.ai/memori-react 8.45.2 → 8.45.5

package/src/helpers/nats/useNatsSession.ts

@@ -1,460 +0,0 @@
-// helpers/nats/useNatsSession.ts - Subscribe to a session's NATS channel.
-//
-// Opens a W3C WebSocket connection (via `wsconnect`), then either:
-// - core NATS: subscribes to the session subject directly, or
-// - JetStream: consumes from the configured stream (ordered consumer by default).
-//
-// When JetStream is enabled, reconnects on tab visibility / network resume and
-// replays the last message per subject to recover events missed while Safari
-// (or other browsers) suspend the WebSocket in background.
-//
-// The cleanup (`consumerMessages.stop()` + `nc.close()`) is essential: without
-// it, every `sessionId` change would leave orphan connections / iterators.
-import { useEffect, useRef, useState, type MutableRefObject } from 'react';
-import {
-  wsconnect,
-  jwtAuthenticator,
-  AuthorizationError,
-  NatsConnection,
-  UserAuthenticationExpiredError,
-} from '@nats-io/nats-core';
-import {
-  jetstream,
-  DeliverPolicy,
-  type ConsumerMessages,
-} from '@nats-io/jetstream';
-import type { NatsConfig } from './getNatsConfig';
-
-/**
- * `progress` event: job advancement updates.
- */
-export interface NatsProgressEvent {
-  eventType: 'progress';
-  jobId?: string;
-  currentStep?: number;
-  finalStep?: number;
-  message?: string;
-  startingTime?: string;
-  correlationID?: string;
-}
-
-/**
- * `dialog.text_entered_response` event: same body returned by
- * `POST /memori/v2/EnterTextAsync/{sessionId}` (via NATS).
- */
-export interface NatsDialogResponseEvent {
-  eventType: 'dialog_text_entered_response';
-  requestID?: string;
-  resultCode?: number;
-  resultMessage?: string;
-  currentState?: any;
-  correlationID?: string;
-}
-
-/**
- * `error` event.
- */
-export interface NatsErrorEvent {
-  eventType: 'error';
-  errorCode?: string | number;
-  errorMessage?: string;
-  backtrace?: string;
-  correlationID?: string;
-}
-
-/**
- * Discriminated union of all events received on the session subject.
- */
-export type NatsSessionEvent =
-  | NatsProgressEvent
-  | NatsDialogResponseEvent
-  | NatsErrorEvent;
-
-type JetStreamConsumeMode = 'live' | 'catch-up';
-
-export interface NatsSessionLifecycle {
-  /** Called after the live subscription is installed. */
-  onConnected?: () => void;
-  /** Called once when this connection is rejected because its JWT expired. */
-  onAuthError?: (error: Error) => void;
-}
-
-export function isNatsAuthError(error: unknown): error is Error {
-  return (
-    error instanceof AuthorizationError ||
-    error instanceof UserAuthenticationExpiredError ||
-    (error instanceof Error &&
-      /authorization violation|authentication expired|user authentication expired/i.test(
-        error.message
-      ))
-  );
-}
-
-function readString(
-  raw: Record<string, unknown>,
-  camelKey: string,
-  snakeKey: string
-): string | undefined {
-  const value = raw[camelKey] ?? raw[snakeKey];
-  return typeof value === 'string' ? value : undefined;
-}
-
-function readNumber(
-  raw: Record<string, unknown>,
-  camelKey: string,
-  snakeKey: string
-): number | undefined {
-  const value = raw[camelKey] ?? raw[snakeKey];
-  return typeof value === 'number' ? value : undefined;
-}
-
-/**
- * Unwraps the `currentState` of a `dialog_text_entered_response`.
- *
- * The async (NATS) response wraps the dialog state one level deeper than the
- * synchronous HTTP response: `currentState` is a `ResponseSpec` that *contains*
- * the actual `DialogState` under a nested `currentState` key. We unwrap it so
- * downstream consumers always receive the `DialogState` directly, while still
- * accepting the already-flat shape for backward compatibility.
- */
-function unwrapDialogState(value: unknown): unknown {
-  if (
-    value &&
-    typeof value === 'object' &&
-    'currentState' in (value as Record<string, unknown>)
-  ) {
-    return (value as Record<string, unknown>).currentState;
-  }
-  return value;
-}
-
-/**
- * Normalizes raw NATS payloads (snake_case or camelCase) into typed events.
- */
-export function normalizeNatsEvent(
-  raw: Record<string, unknown>
-): NatsSessionEvent {
-  const eventType = (readString(raw, 'eventType', 'event_type') ??
-    'unknown') as NatsSessionEvent['eventType'];
-
-  const correlationID =
-    readString(raw, 'correlationID', 'correlation_id') ??
-    readString(raw, 'correlationId', 'correlation_id');
-
-  if (eventType === 'progress') {
-    return {
-      eventType: 'progress',
-      jobId: readString(raw, 'jobId', 'job_id'),
-      currentStep: readNumber(raw, 'currentStep', 'current_step'),
-      finalStep: readNumber(raw, 'finalStep', 'final_step'),
-      message: typeof raw.message === 'string' ? raw.message : undefined,
-      startingTime: readString(raw, 'startingTime', 'starting_time'),
-      correlationID,
-    };
-  }
-
-  if (eventType === 'dialog_text_entered_response') {
-    return {
-      eventType: 'dialog_text_entered_response',
-      requestID: typeof raw.requestID === 'string' ? raw.requestID : undefined,
-      resultCode:
-        typeof raw.resultCode === 'number' ? raw.resultCode : undefined,
-      resultMessage:
-        typeof raw.resultMessage === 'string' ? raw.resultMessage : undefined,
-      currentState: unwrapDialogState(raw.currentState),
-      correlationID,
-    };
-  }
-
-  if (eventType === 'error') {
-    return {
-      eventType: 'error',
-      errorCode: (raw.errorCode ?? raw.error_code) as
-        | string
-        | number
-        | undefined,
-      errorMessage: readString(raw, 'errorMessage', 'error_message'),
-      backtrace: typeof raw.backtrace === 'string' ? raw.backtrace : undefined,
-      correlationID,
-    };
-  }
-
-  return {
-    eventType,
-    correlationID,
-  } as NatsSessionEvent;
-}
-
-function decodeMessage(
-  subject: string,
-  received: number,
-  raw: Record<string, unknown>,
-  onMessage: (event: NatsSessionEvent) => void
-) {
-  const payload = normalizeNatsEvent(raw);
-  console.debug(
-    `[NATS] message #${received} on ${subject} (eventType=${payload.eventType})`,
-    payload
-  );
-  onMessage(payload);
-}
-
-async function consumeCoreSubscription(
-  nc: NatsConnection,
-  subject: string,
-  onMessage: (event: NatsSessionEvent) => void,
-  onReady: () => void
-) {
-  const sub = nc.subscribe(subject);
-  console.info('[NATS] subscribed to subject', subject);
-  onReady();
-  let received = 0;
-  for await (const msg of sub) {
-    received += 1;
-    try {
-      decodeMessage(
-        subject,
-        received,
-        msg.json<Record<string, unknown>>(),
-        onMessage
-      );
-    } catch (err) {
-      console.error('[NATS] message decode error', err);
-    }
-  }
-  console.info(
-    `[NATS] subscription on ${subject} closed (received ${received} messages)`
-  );
-}
-
-async function consumeJetStream(
-  nc: NatsConnection,
-  config: Pick<NatsConfig, 'stream' | 'consumer'>,
-  subject: string,
-  mode: JetStreamConsumeMode,
-  onMessage: (event: NatsSessionEvent) => void,
-  setConsumerMessages: (messages: ConsumerMessages) => void,
-  onReady: () => void
-) {
-  const js = jetstream(nc);
-  const consumer = config.consumer
-    ? await js.consumers.get(config.stream!, config.consumer)
-    : await js.consumers.get(config.stream!, {
-        filter_subjects: [subject],
-        deliver_policy:
-          mode === 'catch-up'
-            ? DeliverPolicy.LastPerSubject
-            : DeliverPolicy.New,
-      });
-
-  console.info(
-    '[NATS] JetStream consumer ready',
-    config.consumer
-      ? { stream: config.stream, consumer: config.consumer, subject, mode }
-      : { stream: config.stream, subject, mode }
-  );
-
-  const messages = await consumer.consume();
-  setConsumerMessages(messages);
-  onReady();
-  let received = 0;
-  for await (const msg of messages) {
-    received += 1;
-    try {
-      decodeMessage(subject, received, msg.json(), onMessage);
-    } catch (err) {
-      console.error('[NATS] message decode error', err);
-    }
-  }
-  console.info(
-    `[NATS] JetStream consumer on ${subject} closed (received ${received} messages)`
-  );
-}
-
-function closeNatsSession(
-  consumerMessagesRef: MutableRefObject<ConsumerMessages | null>,
-  connRef: MutableRefObject<NatsConnection | null>
-) {
-  consumerMessagesRef.current?.stop();
-  consumerMessagesRef.current = null;
-  connRef.current?.close();
-  connRef.current = null;
-}
-
-/**
- * Open a NATS WebSocket connection, subscribe to the session subject and
- * forward decoded events to `onMessage`.
- *
- * `onMessage` is kept in a ref so callers do not need to memoize it: the
- * connection is only (re)opened when `sessionId`, `config` or `resumeGeneration`
- * change.
- *
- * @param sessionId Current session UUID (subscription is skipped when falsy).
- * @param config Connection config from `/api/nats` (url + per-session JWT).
- * @param onMessage Callback invoked for each decoded event.
- */
-export function useNatsSession(
-  sessionId: string | undefined,
-  config: NatsConfig | undefined,
-  onMessage: (event: NatsSessionEvent) => void,
-  lifecycle: NatsSessionLifecycle = {}
-) {
-  const connRef = useRef<NatsConnection | null>(null);
-  const consumerMessagesRef = useRef<ConsumerMessages | null>(null);
-  const onMessageRef = useRef(onMessage);
-  const lifecycleRef = useRef(lifecycle);
-  const wasHiddenRef = useRef(false);
-  const [resumeGeneration, setResumeGeneration] = useState(0);
-
-  // Keep the latest callback without retriggering the connection effect.
-  useEffect(() => {
-    onMessageRef.current = onMessage;
-  }, [onMessage]);
-
-  useEffect(() => {
-    lifecycleRef.current = lifecycle;
-  }, [lifecycle]);
-
-  // Reconnect when the tab returns from background or the network comes back.
-  useEffect(() => {
-    if (!sessionId || !config?.stream) {
-      return;
-    }
-
-    const requestResume = () => {
-      if (document.visibilityState !== 'visible') {
-        return;
-      }
-      console.info('[NATS] resuming JetStream after visibility/network change');
-      setResumeGeneration(generation => generation + 1);
-    };
-
-    const onVisibilityChange = () => {
-      if (document.visibilityState === 'hidden') {
-        wasHiddenRef.current = true;
-        return;
-      }
-      if (wasHiddenRef.current) {
-        wasHiddenRef.current = false;
-        requestResume();
-      }
-    };
-
-    const onPageShow = (event: PageTransitionEvent) => {
-      if (event.persisted) {
-        requestResume();
-      }
-    };
-
-    document.addEventListener('visibilitychange', onVisibilityChange);
-    window.addEventListener('online', requestResume);
-    window.addEventListener('pageshow', onPageShow);
-
-    return () => {
-      document.removeEventListener('visibilitychange', onVisibilityChange);
-      window.removeEventListener('online', requestResume);
-      window.removeEventListener('pageshow', onPageShow);
-    };
-  }, [sessionId, config?.stream]);
-
-  useEffect(() => {
-    if (!sessionId || !config?.url || !config.token) {
-      console.debug(
-        '[NATS] subscription skipped (missing sessionId/url/token)',
-        {
-          sessionId,
-          hasUrl: !!config?.url,
-          hasToken: !!config?.token,
-        }
-      );
-      return;
-    }
-
-    let closed = false;
-    const subject = config.subject ?? `sessions.${sessionId}`;
-    const useJetStream = !!config.stream;
-    const jetStreamMode: JetStreamConsumeMode =
-      useJetStream && resumeGeneration > 0 ? 'catch-up' : 'live';
-
-    (async () => {
-      console.info(
-        '[NATS] connecting to',
-        config.url,
-        'for session',
-        sessionId,
-        useJetStream ? `(JetStream/${jetStreamMode})` : '(core)'
-      );
-      const nc = await wsconnect({
-        servers: [config.url],
-        authenticator: jwtAuthenticator(config.token),
-      });
-      if (closed) {
-        console.debug(
-          '[NATS] connection established after cleanup, closing immediately'
-        );
-        await nc.close();
-        return;
-      }
-      connRef.current = nc;
-      console.info('[NATS] connected to', nc.getServer());
-
-      const dispatch = (event: NatsSessionEvent) => {
-        onMessageRef.current(event);
-      };
-      const ready = () => lifecycleRef.current.onConnected?.();
-      let authRefreshRequested = false;
-      const requestAuthRefresh = (error: Error) => {
-        if (closed || authRefreshRequested) return;
-        authRefreshRequested = true;
-        lifecycleRef.current.onAuthError?.(error);
-      };
-
-      void (async () => {
-        for await (const status of nc.status()) {
-          if (status.type === 'error' && isNatsAuthError(status.error)) {
-            requestAuthRefresh(status.error);
-            return;
-          }
-        }
-      })();
-
-      void nc.closed().then(error => {
-        if (error && isNatsAuthError(error)) {
-          requestAuthRefresh(error);
-        }
-      });
-
-      if (useJetStream) {
-        await consumeJetStream(
-          nc,
-          config,
-          subject,
-          jetStreamMode,
-          dispatch,
-          messages => {
-            consumerMessagesRef.current = messages;
-          },
-          ready
-        );
-      } else {
-        await consumeCoreSubscription(nc, subject, dispatch, ready);
-      }
-    })().catch(err => {
-      console.error('[NATS] connection error', err);
-      if (!closed && isNatsAuthError(err)) {
-        lifecycleRef.current.onAuthError?.(err);
-      }
-    });
-
-    return () => {
-      console.info('[NATS] cleanup: closing connection for subject', subject);
-      closed = true;
-      closeNatsSession(consumerMessagesRef, connRef);
-    };
-  }, [sessionId, config, resumeGeneration]);
-
-  // Reset catch-up generation when the active session changes.
-  useEffect(() => {
-    setResumeGeneration(0);
-  }, [sessionId]);
-}

package/src/helpers/piiDetection.test.ts

@@ -1,186 +0,0 @@
-import { checkPii } from './piiDetection';
-
-const baseConfig = {
-  enabled: true,
-  rules: [
-    {
-      id: 'email',
-      label: { it: 'Email', en: 'Email' },
-      pattern: '\\b[A-Za-z0-9._%+\\-]+@[A-Za-z0-9.\\-]+\\.[A-Za-z]{2,}\\b',
-      message: { it: 'Contiene email.', en: 'Contains email.' },
-    },
-    {
-      id: 'iban',
-      label: { it: 'IBAN', en: 'IBAN' },
-      pattern: '\\b[A-Z]{2}\\d{2}(?:[ ]?[A-Z0-9]{4}){3,7}(?:[ ]?[A-Z0-9]{1,4})?\\b',
-      message: { it: 'Contiene IBAN.', en: 'Contains IBAN.' },
-    },
-  ],
-  errorMessage: {
-    it: 'Dati sensibili.',
-    en: 'Sensitive data.',
-  },
-};
-
-describe('checkPii', () => {
-  describe('edge cases: no match', () => {
-    it('returns no match when config is disabled', () => {
-      expect(
-        checkPii('test@example.com', { ...baseConfig, enabled: false }, 'en')
-      ).toEqual({ matched: false });
-    });
-
-    it('returns no match when config is null', () => {
-      expect(checkPii('hello', null as any, 'en')).toEqual({ matched: false });
-    });
-
-    it('returns no match when config is undefined', () => {
-      expect(checkPii('hello', undefined as any, 'en')).toEqual({
-        matched: false,
-      });
-    });
-
-    it('returns no match when rules is empty array', () => {
-      expect(
-        checkPii('test@example.com', { ...baseConfig, rules: [] }, 'en')
-      ).toEqual({ matched: false });
-    });
-
-    it('returns no match when rules is not an array', () => {
-      expect(
-        checkPii('test@example.com', { ...baseConfig, rules: null as any }, 'en')
-      ).toEqual({ matched: false });
-    });
-
-    it('returns no match when no rule matches the text', () => {
-      expect(checkPii('just plain hello world', baseConfig, 'en')).toEqual({
-        matched: false,
-      });
-    });
-
-    it('skips rules with empty pattern (avoids matching everything)', () => {
-      const configWithEmptyPattern = {
-        ...baseConfig,
-        rules: [
-          { id: 'empty', label: { it: 'Empty', en: 'Empty' }, pattern: '', message: { en: 'Empty' } },
-          {
-            id: 'space',
-            label: { it: 'Space', en: 'Space' },
-            pattern: '   ',
-            message: { en: 'Space' },
-          },
-        ],
-      };
-      expect(checkPii('anything at all', configWithEmptyPattern, 'en')).toEqual(
-        { matched: false }
-      );
-    });
-
-    it('treats invalid regex as no match and does not throw', () => {
-      const warnSpy = jest.spyOn(console, 'warn').mockImplementation();
-      const configBadRegex = {
-        ...baseConfig,
-        rules: [
-          {
-            id: 'bad',
-            label: { it: 'Bad', en: 'Bad' },
-            pattern: '[unclosed',
-            message: { en: 'Bad' },
-          },
-        ],
-      };
-      expect(checkPii('test', configBadRegex, 'en')).toEqual({ matched: false });
-      expect(warnSpy).toHaveBeenCalledWith(
-        '[PII] Invalid regex for rule:',
-        'bad',
-        '[unclosed',
-        expect.any(Error)
-      );
-      warnSpy.mockRestore();
-    });
-  });
-
-  describe('single rule match', () => {
-    it('returns match and errorText when email pattern matches', () => {
-      const result = checkPii('contact me at test@example.com please', baseConfig, 'en');
-      expect(result.matched).toBe(true);
-      expect(result.errorText).toContain('Sensitive data.');
-      expect(result.errorText).toContain('Contains email.');
-      expect(result.errorText).not.toContain('Contains IBAN.');
-    });
-
-    it('returns match with Italian messages when lang is it', () => {
-      const result = checkPii('test@example.com', baseConfig, 'it');
-      expect(result.matched).toBe(true);
-      expect(result.errorText).toContain('Dati sensibili.');
-      expect(result.errorText).toContain('Contiene email.');
-    });
-
-    it('falls back to en when lang has no translation', () => {
-      const result = checkPii('test@example.com', baseConfig, 'fr');
-      expect(result.matched).toBe(true);
-      expect(result.errorText).toContain('Sensitive data.');
-      expect(result.errorText).toContain('Contains email.');
-    });
-
-    it('falls back to first available message when errorMessage has no en or requested lang', () => {
-      const configNoEn = {
-        ...baseConfig,
-        errorMessage: { it: 'Solo italiano' },
-      };
-      const result = checkPii('test@example.com', configNoEn, 'de');
-      expect(result.matched).toBe(true);
-      expect(result.errorText).toContain('Solo italiano');
-    });
-  });
-
-  describe('multiple rules and deduplication', () => {
-    it('returns match with both rule messages when text matches email and IBAN', () => {
-      const text = 'send to test@example.com and IT60X0542811101000000123456';
-      const result = checkPii(text, baseConfig, 'en');
-      expect(result.matched).toBe(true);
-      expect(result.errorText).toContain('Sensitive data.');
-      expect(result.errorText).toContain('Contains email.');
-      expect(result.errorText).toContain('Contains IBAN.');
-    });
-
-    it('deduplicates by rule id when multiple rules share same id', () => {
-      const configDupId = {
-        ...baseConfig,
-        rules: [
-          {
-            id: 'email',
-            label: { it: 'Email 1', en: 'Email 1' },
-            pattern: '\\b[A-Za-z0-9._%+\\-]+@[A-Za-z0-9.\\-]+\\.[A-Za-z]{2,}\\b',
-            message: { en: 'Email 1' },
-          },
-          {
-            id: 'email',
-            label: { it: 'Email 2', en: 'Email 2' },
-            pattern: '@',
-            message: { en: 'Email 2' },
-          },
-        ],
-      };
-      const result = checkPii('test@example.com', configDupId, 'en');
-      expect(result.matched).toBe(true);
-      const lines = result.errorText!.split('\n');
-      const emailLines = lines.filter(l => l.includes('Email'));
-      expect(emailLines.length).toBe(1);
-    });
-  });
-
-  describe('lang normalization', () => {
-    it('handles empty string lang with fallback to en', () => {
-      const result = checkPii('test@example.com', baseConfig, '');
-      expect(result.matched).toBe(true);
-      expect(result.errorText).toContain('Sensitive data.');
-    });
-
-    it('normalizes lang to lowercase for lookup', () => {
-      const result = checkPii('test@example.com', baseConfig, 'EN');
-      expect(result.matched).toBe(true);
-      expect(result.errorText).toContain('Sensitive data.');
-    });
-  });
-});