@redacto.io/consent-sdk-react 4.0.0 → 5.0.0

package/src/RedactoPrivacyCenter/lib/api.ts

@@ -0,0 +1,566 @@
+import {
+  createCaseRequestServer,
+  fetchActivitiesServer,
+  fetchCaseHistoryServer,
+  fetchProductsServer,
+  fetchUserConsentsServer,
+  getFormDataServer,
+  manageConsentServer,
+  getCaseMessagesServer,
+  sendCaseMessageServer,
+  uploadCaseDocumentServer,
+  submitDocumentForRequestServer,
+  getCaseDocumentServer,
+} from '../api/actions';
+import type { BaseUrlContextValue } from '../context/BaseUrlContext';
+import type {
+  ActivityDetail,
+  CaseHistoryDetail,
+  CaseMessage,
+  CreateCaseResponse,
+  FormData,
+  MessageDocument,
+  UploadDocumentResponse,
+  UserConsentDetail,
+  UserDataRequest,
+} from './types';
+import { ensureValidToken } from './utils';
+
+// Auth context type for passing to API functions
+export interface AuthContext {
+  accessToken?: string;
+  refreshToken?: string;
+  onError?: (error: Error) => boolean;
+  updateTokens?: (accessToken: string, refreshToken?: string) => void;
+}
+
+// Re-export server actions for client components
+export {
+  createOtpServer as createOtp,
+  exchangeTokenServer as exchangeToken,
+  verifyOtpServer as verifyOtp,
+} from '../api/actions';
+
+// Re-export refreshOtpTokenServer for utils
+export { refreshOtpTokenServer } from '../api/actions';
+
+// Re-export types
+export type {
+  ActivityDetail,
+  CaseHistoryDetail,
+  CreateCaseResponse,
+  FormData,
+  OrganizationResponse,
+  OtpResponse,
+  OtpVerificationResponse,
+  TokenExchangeResponse,
+  UserConsentDetail,
+  UserDataRequest,
+} from './types';
+
+// Keep utility functions
+export { getCookieValue } from './utils';
+
+/**
+ * Check if an error is an authentication/JWT related error
+ */
+function isAuthError(error: any): boolean {
+  const errorMessage = error?.message || '';
+  return (
+    errorMessage.includes('401') ||
+    errorMessage.includes('JWT') ||
+    errorMessage.includes('expired') ||
+    errorMessage.includes('token') ||
+    errorMessage.includes('Unauthorized')
+  );
+}
+
+/**
+ * Handle client-side auth errors by attempting token refresh
+ * If refresh fails, signs out and redirects to sign-in
+ * @returns true if token was refreshed successfully and caller should retry, false otherwise
+ */
+async function handleClientAuthError(
+  error: any,
+  organizationId: string,
+  workspaceId: string,
+  authContext?: AuthContext,
+  consentClient?: BaseUrlContextValue['consentClient']
+): Promise<boolean> {
+  if (isAuthError(error)) {
+    // Try to get a fresh token
+    const newToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
+    if (newToken) {
+      // Token refresh succeeded - caller should retry with new token
+      return true;
+    }
+    // Token refresh failed - ensureValidToken already handled sign out and redirect
+    return false;
+  }
+  return false;
+}
+
+export const getFormData = async (
+  organizationId: string,
+  workspaceId: string,
+  contact: string,
+  _isPopup?: boolean,
+  useSessionAuth?: boolean,
+  authContext?: AuthContext,
+  consentClient?: BaseUrlContextValue['consentClient'],
+  language?: string
+): Promise<FormData | null> => {
+  try {
+    // If useSessionAuth is explicitly set to true (case management), use session auth
+    if (useSessionAuth) {
+      return await getFormDataServer(organizationId, workspaceId, contact, undefined, true, consentClient, language);
+    }
+
+    // Ensure we have a valid token before making the API call
+    const authToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
+    if (!authToken) {
+      // ensureValidToken already handled sign out and redirect
+      return null;
+    }
+
+    const data = await getFormDataServer(
+      organizationId,
+      workspaceId,
+      contact,
+      authToken,
+      false,
+      consentClient,
+      language
+    );
+    return data;
+  } catch (error: any) {
+    const shouldRetry = await handleClientAuthError(error, organizationId, workspaceId, authContext, consentClient);
+    if (shouldRetry) {
+      // Read from sessionStorage first (synchronously updated) then fall back to context
+      const newAuthToken = sessionStorage.getItem('access_token') || authContext?.accessToken || '';
+      return await getFormDataServer(
+        organizationId,
+        workspaceId,
+        contact,
+        newAuthToken,
+        false,
+        consentClient,
+        language
+      );
+    }
+    console.error('Error fetching form data:', error);
+    if (error.message?.includes('404')) {
+      throw error;
+    }
+    return null;
+  }
+};
+
+export const createCaseRequest = async (
+  organizationId: string,
+  workspaceId: string,
+  data: UserDataRequest,
+  _isPopup?: boolean,
+  useSessionAuth?: boolean,
+  authContext?: AuthContext,
+  consentClient?: BaseUrlContextValue['consentClient']
+): Promise<CreateCaseResponse | null> => {
+  try {
+    // If useSessionAuth is explicitly set to true (case management), use session auth
+    if (useSessionAuth) {
+      return await createCaseRequestServer(organizationId, workspaceId, data, undefined, true, consentClient);
+    }
+
+    // Ensure we have a valid token before making the API call
+    const authToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
+    if (!authToken) {
+      // ensureValidToken already handled sign out and redirect
+      return null;
+    }
+
+    return await createCaseRequestServer(
+      organizationId,
+      workspaceId,
+      data,
+      authToken,
+      false,
+      consentClient
+    );
+  } catch (error: any) {
+    const shouldRetry = await handleClientAuthError(error, organizationId, workspaceId, authContext, consentClient);
+    if (shouldRetry) {
+      // Read from sessionStorage first (synchronously updated) then fall back to context
+      const newAuthToken = sessionStorage.getItem('access_token') || authContext?.accessToken || '';
+      return await createCaseRequestServer(
+        organizationId,
+        workspaceId,
+        data,
+        newAuthToken,
+        false,
+        consentClient
+      );
+    }
+    console.error('Error creating case request:', error);
+    return null;
+  }
+};
+
+export const fetchProducts = async (
+  organizationId: string,
+  workspaceId: string,
+  skip?: number,
+  limit?: number,
+  authContext?: AuthContext,
+  consentClient?: BaseUrlContextValue['consentClient']
+): Promise<Array<{ uuid: string; name: string; description?: string }> | null> => {
+  try {
+    // Ensure we have a valid token before making the API call
+    const accessToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
+    if (!accessToken) {
+      // ensureValidToken already handled sign out and redirect
+      return null;
+    }
+
+    const result = await fetchProductsServer({
+      organizationId,
+      workspaceId,
+      skip,
+      limit,
+      authToken: accessToken,
+      consentClient,
+    });
+    return result;
+  } catch (error: any) {
+    const shouldRetry = await handleClientAuthError(error, organizationId, workspaceId, authContext, consentClient);
+    if (shouldRetry) {
+      // Read from sessionStorage first (synchronously updated) then fall back to context
+      const newAccessToken = sessionStorage.getItem('access_token') || authContext?.accessToken || '';
+      return await fetchProductsServer({
+        organizationId,
+        workspaceId,
+        skip,
+        limit,
+        authToken: newAccessToken || undefined,
+        consentClient,
+      });
+    }
+    console.error('Error fetching products:', error);
+    return null;
+  }
+};
+
+export const fetchUserConsents = async (
+  organizationId: string,
+  workspaceId: string,
+  contact: string,
+  offset?: number,
+  limit?: number,
+  search?: string,
+  status?: string,
+  product_uuid?: string,
+  authContext?: AuthContext,
+  consentClient?: BaseUrlContextValue['consentClient'],
+  language?: string
+): Promise<UserConsentDetail | null> => {
+  try {
+    // Ensure we have a valid token before making the API call
+    const accessToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
+    if (!accessToken) {
+      // ensureValidToken already handled sign out and redirect
+      return null;
+    }
+
+    const result = await fetchUserConsentsServer({
+      organizationId,
+      workspaceId,
+      contact,
+      offset,
+      limit,
+      search,
+      status,
+      product_uuid,
+      language,
+      authToken: accessToken,
+      consentClient,
+    });
+    return result;
+  } catch (error: any) {
+    const shouldRetry = await handleClientAuthError(error, organizationId, workspaceId, authContext, consentClient);
+    if (shouldRetry) {
+      // Read from sessionStorage first (synchronously updated) then fall back to context
+      const newAccessToken = sessionStorage.getItem('access_token') || authContext?.accessToken || '';
+      return await fetchUserConsentsServer({
+        organizationId,
+        workspaceId,
+        contact,
+        offset,
+        limit,
+        search,
+        status,
+        product_uuid,
+        language,
+        authToken: newAccessToken || undefined,
+        consentClient,
+      });
+    }
+    console.error('Error fetching user consent data:', error);
+    return null;
+  }
+};
+
+export const manageConsent = async ({
+  organizationId,
+  workspaceId,
+  purposeId,
+  contact,
+  action,
+  authContext,
+  consentClient,
+  nominatorContact,
+  dataElementUuids,
+}: {
+  organizationId: string;
+  workspaceId: string;
+  purposeId: string;
+  contact: string;
+  action: 'revoke' | 'regrant' | 'renew';
+  authContext?: AuthContext;
+  consentClient?: BaseUrlContextValue['consentClient'];
+  nominatorContact?: string;
+  dataElementUuids?: string[];
+}): Promise<boolean | null> => {
+  try {
+    // Ensure we have a valid token before making the API call
+    const accessToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
+    if (!accessToken) {
+      // ensureValidToken already handled sign out and redirect
+      return null;
+    }
+
+    const result = await manageConsentServer({
+      organizationId,
+      workspaceId,
+      purposeId,
+      contact,
+      action,
+      authToken: accessToken,
+      consentClient,
+      nominatorContact,
+      dataElementUuids,
+    });
+    return result;
+  } catch (error: any) {
+    // Re-throw nominator-specific errors (stable code) so the UI can show targeted messages
+    if (error?.name === 'ConsentApiError') {
+      throw error;
+    }
+    // Auth errors (401) mean the request was rejected before processing, so a single retry is safe
+    const recovered = await handleClientAuthError(error, organizationId, workspaceId, authContext, consentClient);
+    if (recovered) {
+      const newAccessToken = sessionStorage.getItem('access_token') || authContext?.accessToken || '';
+      return await manageConsentServer({
+        organizationId,
+        workspaceId,
+        purposeId,
+        contact,
+        action,
+        authToken: newAccessToken || undefined,
+        consentClient,
+        nominatorContact,
+        dataElementUuids,
+      });
+    }
+    console.error(`Error ${action} consent:`, error);
+    return null;
+  }
+};
+
+export const fetchActivities = async (
+  organizationId: string,
+  workspaceId: string,
+  offset?: number,
+  limit?: number,
+  authContext?: AuthContext,
+  consentClient?: BaseUrlContextValue['consentClient'],
+  language?: string
+): Promise<ActivityDetail | null> => {
+  try {
+    // Ensure we have a valid token before making the API call
+    const accessToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
+    if (!accessToken) {
+      // ensureValidToken already handled sign out and redirect
+      return null;
+    }
+
+    const result = await fetchActivitiesServer({
+      organizationId,
+      workspaceId,
+      offset,
+      limit,
+      language,
+      authToken: accessToken,
+      consentClient,
+    });
+    return result;
+  } catch (error: any) {
+    const shouldRetry = await handleClientAuthError(error, organizationId, workspaceId, authContext, consentClient);
+    if (shouldRetry) {
+      // Read from sessionStorage first (synchronously updated) then fall back to context
+      const newAccessToken = sessionStorage.getItem('access_token') || authContext?.accessToken || '';
+      return await fetchActivitiesServer({
+        organizationId,
+        workspaceId,
+        offset,
+        limit,
+        language,
+        authToken: newAccessToken || undefined,
+        consentClient,
+      });
+    }
+    console.error('Error fetching activities:', error);
+    return null;
+  }
+};
+
+export const fetchCaseHistory = async (
+  organizationId: string,
+  workspaceId: string,
+  contact: string,
+  offset?: number,
+  limit?: number,
+  authContext?: AuthContext,
+  consentClient?: BaseUrlContextValue['consentClient'],
+  language?: string
+): Promise<CaseHistoryDetail | null> => {
+  try {
+    // Ensure we have a valid token before making the API call
+    const accessToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
+    if (!accessToken) {
+      // ensureValidToken already handled sign out and redirect
+      return null;
+    }
+
+    const result = await fetchCaseHistoryServer({
+      organizationId,
+      workspaceId,
+      contact,
+      offset,
+      limit,
+      language,
+      authToken: accessToken,
+      consentClient,
+    });
+    return result;
+  } catch (error: any) {
+    const shouldRetry = await handleClientAuthError(error, organizationId, workspaceId, authContext, consentClient);
+    if (shouldRetry) {
+      // Read from sessionStorage first (synchronously updated) then fall back to context
+      const newAccessToken = sessionStorage.getItem('access_token') || authContext?.accessToken || '';
+      return await fetchCaseHistoryServer({
+        organizationId,
+        workspaceId,
+        contact,
+        offset,
+        limit,
+        language,
+        authToken: newAccessToken || undefined,
+        consentClient,
+      });
+    }
+    console.error('Error fetching case history: ', error);
+    return null;
+  }
+};
+
+// ─── Auth-retry helper ──────────────────────────────────────────────────────
+
+/**
+ * Wraps an API call with token acquisition and single-retry-on-auth-error logic.
+ * `fn` receives a valid access token and returns the API result.
+ */
+async function withAuthRetry<T>(
+  organizationId: string,
+  workspaceId: string,
+  authContext: AuthContext | undefined,
+  consentClient: BaseUrlContextValue['consentClient'] | undefined,
+  errorLabel: string,
+  fn: (token: string) => Promise<T>
+): Promise<T | null> {
+  try {
+    const accessToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
+    if (!accessToken) return null;
+    return await fn(accessToken);
+  } catch (error: any) {
+    const shouldRetry = await handleClientAuthError(error, organizationId, workspaceId, authContext, consentClient);
+    if (shouldRetry) {
+      const token = sessionStorage.getItem('access_token') || authContext?.accessToken || '';
+      return await fn(token);
+    }
+    console.error(errorLabel, error);
+    return null;
+  }
+}
+
+// ─── Case Communication ──────────────────────────────────────────────────────
+
+export const getCaseMessages = async (
+  organizationId: string,
+  workspaceId: string,
+  caseUuid: string,
+  authContext?: AuthContext,
+  consentClient?: BaseUrlContextValue['consentClient']
+): Promise<CaseMessage[] | null> =>
+  withAuthRetry(organizationId, workspaceId, authContext, consentClient, 'Error fetching case messages:', (token) =>
+    getCaseMessagesServer({ organizationId, workspaceId, caseUuid, authToken: token, consentClient })
+  );
+
+export const sendCaseMessage = async (
+  organizationId: string,
+  workspaceId: string,
+  caseUuid: string,
+  body: string,
+  documentUuids: string[],
+  authContext?: AuthContext,
+  consentClient?: BaseUrlContextValue['consentClient']
+): Promise<CaseMessage | null> =>
+  withAuthRetry(organizationId, workspaceId, authContext, consentClient, 'Error sending case message:', (token) =>
+    sendCaseMessageServer({ organizationId, workspaceId, caseUuid, body, documentUuids, authToken: token, consentClient })
+  );
+
+export const uploadCaseDocument = async (
+  organizationId: string,
+  workspaceId: string,
+  caseUuid: string,
+  file: File,
+  authContext?: AuthContext,
+  consentClient?: BaseUrlContextValue['consentClient']
+): Promise<UploadDocumentResponse | null> =>
+  withAuthRetry(organizationId, workspaceId, authContext, consentClient, 'Error uploading case document:', (token) =>
+    uploadCaseDocumentServer({ organizationId, workspaceId, caseUuid, file, authToken: token, consentClient })
+  );
+
+export const submitDocumentForRequest = async (
+  organizationId: string,
+  workspaceId: string,
+  caseUuid: string,
+  requestEventUuid: string,
+  documentUuid: string,
+  body: string,
+  authContext?: AuthContext,
+  consentClient?: BaseUrlContextValue['consentClient']
+): Promise<CaseMessage | null> =>
+  withAuthRetry(organizationId, workspaceId, authContext, consentClient, 'Error submitting document for request:', (token) =>
+    submitDocumentForRequestServer({ organizationId, workspaceId, caseUuid, requestEventUuid, documentUuid, body, authToken: token, consentClient })
+  );
+
+export const getCaseDocument = async (
+  organizationId: string,
+  workspaceId: string,
+  caseUuid: string,
+  documentUuid: string,
+  authContext?: AuthContext,
+  consentClient?: BaseUrlContextValue['consentClient']
+): Promise<MessageDocument | null> =>
+  withAuthRetry(organizationId, workspaceId, authContext, consentClient, 'Error fetching case document:', (token) =>
+    getCaseDocumentServer({ organizationId, workspaceId, caseUuid, documentUuid, authToken: token, consentClient })
+  );

package/src/RedactoPrivacyCenter/lib/consent-manager/utils.tsx

@@ -0,0 +1,63 @@
+import { useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+import { ConsentStatusEnum } from '../types';
+import type { UserConsent } from '../types';
+import { formatDateTime as formatDateTimeShared } from '../../utils/date';
+
+// Re-export shared date formatting
+export const formatDateTime = formatDateTimeShared;
+
+export const useStatusOptions = () => {
+  const { t } = useTranslation();
+  return useMemo(
+    () => [
+      { label: t('statusActive'), value: ConsentStatusEnum.ACTIVE },
+      { label: t('statusWithdrawn'), value: ConsentStatusEnum.WITHDRAWN },
+      { label: t('statusExpired'), value: ConsentStatusEnum.EXPIRED },
+      { label: t('statusDeclined'), value: ConsentStatusEnum.DECLINED },
+    ],
+    [t]
+  );
+};
+
+export const exportTableToCSV = (rows: UserConsent[]) => {
+  if (!rows || rows.length === 0) {
+    console.warn('No data to export');
+    return;
+  }
+
+  const excludedFields = ['Action', 'data_elements'];
+  const headers = Array.from(new Set(rows.flatMap((r) => Object.keys(r))))
+    .filter((key) => !excludedFields.includes(key))
+    .map((key) => key.toUpperCase())
+    .join(',');
+
+  const csvRows = rows.map((row) => {
+    return Object.entries(row)
+      .filter(([key]) => !excludedFields.includes(key))
+      .map(([key, value]) => {
+        let formattedValue = value;
+        if ((key === 'given_date' || key === 'valid_till') && value) {
+          formattedValue = formatDateTime(String(value));
+        }
+        return `"${String(formattedValue).replace(/"/g, '""')}"`;
+      })
+      .join(',');
+  });
+
+  const csvContent = [headers, ...csvRows].join('\n');
+
+  try {
+    const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement('a');
+    link.href = url;
+    link.setAttribute('download', `consent-records.csv`);
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+  } catch (error) {
+    console.error('Failed to export CSV:', error);
+  }
+};