@redacto.io/consent-sdk-react 10.0.0-beta.11 → 10.0.0-beta.12

package/src/RedactoPrivacyCenter/api/actions.ts

@@ -1,682 +0,0 @@
-import type { BaseRequest } from './client';
-import { isTerminalRefreshError } from './fetcher';
-
-export type ConsentApiErrorCode = 'NOMINATOR_NOT_FOUND' | 'NOMINEE_MUST_SPECIFY_NOMINATOR';
-
-export class ConsentApiError extends Error {
-  code: ConsentApiErrorCode;
-  constructor(code: ConsentApiErrorCode, message: string) {
-    super(message);
-    this.name = 'ConsentApiError';
-    this.code = code;
-  }
-}
-
-import type {
-  ActivityDetail,
-  CaseActionBaseParams,
-  CaseHistoryDetail,
-  CaseMessage,
-  ConsentAction,
-  CreateCaseResponse,
-  FormData,
-  GetCaseDocumentParams,
-  GetCaseMessagesParams,
-  MessageDocument,
-  GetNotificationsServerParams,
-  LegacyManageConsentResponse,
-  NotificationActionBaseParams,
-  NotificationActionResponse,
-  NotificationByUuidServerParams,
-  NotificationClient,
-  NotificationListResponse,
-  NotificationSummary,
-  OtpResponse,
-  OtpVerificationResponse,
-  Pagination,
-  SendCaseMessageParams,
-  SubmitDocumentForRequestParams,
-  TokenExchangeResponse,
-  UnreadCountResponse,
-  UploadCaseDocumentParams,
-  UploadDocumentResponse,
-  UserConsentDetail,
-  GroupPurposesOut,
-} from '../lib/types';
-
-function buildBaseRequest(organizationId: string, workspaceId: string, authToken?: string): BaseRequest {
-  return { organisationUuid: organizationId, workspaceUuid: workspaceId, authToken: authToken || '' };
-}
-
-/**
- * Check if an error is an authentication/JWT related error
- */
-function isAuthError(error: any): boolean {
-  const errorMessage = error?.message || '';
-  return (
-    errorMessage.includes('JWT') ||
-    errorMessage.includes('401') ||
-    errorMessage.includes('expired') ||
-    errorMessage.includes('token')
-  );
-}
-
-/**
- * Handle server action errors - re-throws auth errors, logs others
- */
-function handleServerActionError(
-  error: any,
-  errorContext: string,
-  shouldThrow404 = false
-): null {
-  // Re-throw auth errors so client can handle refresh
-  if (isAuthError(error)) {
-    throw error;
-  }
-  console.error(`Error ${errorContext}:`, error);
-  if (shouldThrow404 && error.message?.includes('404')) {
-    throw error;
-  }
-  return null;
-}
-
-export async function getFormDataServer(
-  organizationId: string,
-  workspaceId: string,
-  contact: string,
-  authToken?: string,
-  useSessionAuth?: boolean,
-  consentClient?: ReturnType<typeof import('./client').createConsentClient>,
-  language?: string
-): Promise<FormData | null> {
-  try {
-    if (!consentClient) {
-      throw new Error('Consent client is required');
-    }
-    const baseRequest = buildBaseRequest(organizationId, workspaceId, authToken);
-
-    // If useSessionAuth is true (case management), use X-Auth-Token
-    // Otherwise (privacy center), use JWT Bearer token
-    const result = await consentClient.getFormData(baseRequest, contact, authToken, {
-      useSessionAuth: useSessionAuth ?? false, // Default to false for privacy center
-    }, language);
-    return result as FormData;
-  } catch (error: any) {
-    return handleServerActionError(error, 'fetching form data', true);
-  }
-}
-
-export async function createCaseRequestServer(
-  organizationId: string,
-  workspaceId: string,
-  data: unknown,
-  authToken?: string,
-  useSessionAuth?: boolean,
-  consentClient?: ReturnType<typeof import('./client').createConsentClient>
-): Promise<CreateCaseResponse | null> {
-  try {
-    if (!consentClient) {
-      throw new Error('Consent client is required');
-    }
-    const baseRequest = buildBaseRequest(organizationId, workspaceId, authToken);
-
-    // If useSessionAuth is true (case management), use X-Auth-Token
-    // Otherwise (privacy center), use JWT Bearer token
-    const result = await consentClient.createCaseRequest(baseRequest, data, authToken, {
-      useSessionAuth: useSessionAuth ?? false, // Default to false for privacy center
-    });
-    return result as CreateCaseResponse;
-  } catch (error: any) {
-    return handleServerActionError(error, 'creating case request');
-  }
-}
-
-export async function createOtpServer(
-  email: string,
-  organizationId: string,
-  workspaceId: string,
-  consentClient?: ReturnType<typeof import('./client').createConsentClient>
-): Promise<OtpResponse> {
-  try {
-    if (!consentClient) {
-      throw new Error('Consent client is required');
-    }
-    const result = await consentClient.createOtp(organizationId, workspaceId, email);
-    return result as OtpResponse;
-  } catch (error) {
-    console.error('Error creating OTP:', error);
-    throw error;
-  }
-}
-
-export async function verifyOtpServer(
-  otpId: string,
-  otp: string,
-  organizationId: string,
-  workspaceId: string,
-  consentClient?: ReturnType<typeof import('./client').createConsentClient>
-): Promise<OtpVerificationResponse> {
-  try {
-    if (!consentClient) {
-      throw new Error('Consent client is required');
-    }
-    const result = await consentClient.verifyOtp(organizationId, workspaceId, otpId, otp);
-    const response = result as OtpVerificationResponse;
-    return response;
-  } catch (error) {
-    console.error('Error verifying OTP:', error);
-    throw error;
-  }
-}
-
-export async function exchangeTokenServer(
-  token: string,
-  consentClient?: ReturnType<typeof import('./client').createConsentClient>
-): Promise<TokenExchangeResponse> {
-  try {
-    if (!consentClient) {
-      throw new Error('Consent client is required');
-    }
-    const result = await consentClient.exchangeToken(token);
-    return result as TokenExchangeResponse;
-  } catch (error) {
-    console.error('Error exchanging token:', error);
-    throw error;
-  }
-}
-
-export async function refreshOtpTokenServer(
-  organizationId: string,
-  workspaceId: string,
-  refreshToken: string,
-  consentClient?: ReturnType<typeof import('./client').createConsentClient>
-): Promise<OtpResponse | null> {
-  // Validate refreshToken before making API call
-  if (!refreshToken || typeof refreshToken !== 'string' || refreshToken.trim() === '') {
-    console.error('[Token Refresh] Invalid refresh token provided');
-    return null;
-  }
-
-  // Validate organizationId and workspaceId
-  if (!organizationId || !workspaceId) {
-    console.error('[Token Refresh] Missing organizationId or workspaceId');
-    return null;
-  }
-
-  try {
-    if (!consentClient) {
-      throw new Error('Consent client is required');
-    }
-    const result = await consentClient.refreshOtpToken(
-      organizationId,
-      workspaceId,
-      refreshToken
-    );
-
-    const response = result as OtpResponse;
-    // Check if the response indicates failure
-    if (response && response.success === false) {
-      // Return null to indicate refresh failed
-      return null;
-    }
-    return response;
-  } catch (error: any) {
-    // Terminal token errors (expired / not found / already used / 4xx) are an
-    // expected outcome — return null so the caller trips the circuit breaker
-    // instead of treating it as a retryable exception (incident 2026-06-22).
-    if (isTerminalRefreshError(error)) {
-      return null;
-    }
-
-    // Transient errors (network / 5xx): re-throw so the caller can back off + retry.
-    console.error('Error refreshing token:', error);
-    throw error;
-  }
-}
-
-export async function fetchProductsServer(params: {
-  organizationId: string;
-  workspaceId: string;
-  skip?: number;
-  limit?: number;
-  authToken?: string;
-  consentClient?: ReturnType<typeof import('./client').createConsentClient>;
-}): Promise<Array<{ uuid: string; name: string; description?: string }> | null> {
-  try {
-    if (!params.consentClient) {
-      throw new Error('Consent client is required');
-    }
-    // Privacy center endpoints use JWT Bearer tokens, not session-based auth
-    const baseRequest = buildBaseRequest(params.organizationId, params.workspaceId, params.authToken);
-
-    const result = await params.consentClient.getProducts(
-      baseRequest,
-      params.skip || 0,
-      params.limit || 100 // Get more products for filter dropdown
-    );
-    return (result as { data?: Array<{ uuid: string; name: string; description?: string }> })?.data || [];
-  } catch (error: any) {
-    return handleServerActionError(error, 'fetching products');
-  }
-}
-
-export async function fetchUserConsentsServer(params: {
-  organizationId: string;
-  workspaceId: string;
-  offset?: number;
-  limit?: number;
-  nominatedOffset?: number;
-  nominatedLimit?: number;
-  search?: string;
-  status?: string;
-  product_uuid?: string;
-  language?: string;
-  authToken?: string;
-  consentClient?: ReturnType<typeof import('./client').createConsentClient>;
-}): Promise<UserConsentDetail | null> {
-  try {
-    if (!params.consentClient) {
-      throw new Error('Consent client is required');
-    }
-    // Privacy center endpoints use JWT Bearer tokens, not session-based auth
-    const baseRequest = buildBaseRequest(params.organizationId, params.workspaceId, params.authToken);
-
-    const result = await params.consentClient.getUserConsents(
-      baseRequest,
-      {
-        offset: params.offset,
-        limit: params.limit,
-        nominated_offset: params.nominatedOffset,
-        nominated_limit: params.nominatedLimit,
-        status: params.status,
-        product_uuid: params.product_uuid,
-        search: params.search,
-        language: params.language,
-      },
-      params.authToken
-    );
-
-    return result as UserConsentDetail;
-  } catch (error: any) {
-    return handleServerActionError(error, 'fetching user consents');
-  }
-}
-
-export async function fetchGroupPurposesServer(params: {
-  organizationId: string;
-  workspaceId: string;
-  productUuid: string;
-  offset?: number;
-  limit?: number;
-  status?: string;
-  search?: string;
-  language?: string;
-  nominatorUuid?: string;
-  authToken?: string;
-  consentClient?: ReturnType<typeof import('./client').createConsentClient>;
-}): Promise<GroupPurposesOut | null> {
-  try {
-    if (!params.consentClient) {
-      throw new Error('Consent client is required');
-    }
-    const baseRequest = buildBaseRequest(params.organizationId, params.workspaceId, params.authToken);
-
-    const result = await params.consentClient.getGroupPurposes(
-      baseRequest,
-      params.productUuid,
-      {
-        offset: params.offset,
-        limit: params.limit,
-        status: params.status,
-        search: params.search,
-        language: params.language,
-        nominator_uuid: params.nominatorUuid,
-      },
-      params.authToken
-    );
-
-    return result as GroupPurposesOut;
-  } catch (error: any) {
-    return handleServerActionError(error, 'fetching group purposes');
-  }
-}
-
-export async function manageConsentServer(params: {
-  organizationId: string;
-  workspaceId: string;
-  purposeId: string;
-  contact: string;
-  action: ConsentAction;
-  authToken?: string;
-  consentClient?: ReturnType<typeof import('./client').createConsentClient>;
-  nominatorContact?: string;
-  dataElementUuids?: string[];
-  productUuid?: string;
-  noticeUuid?: string;
-  dataElements?: Array<{ uuid: string; selected: boolean }>;
-  language?: string;
-}): Promise<boolean | null> {
-  try {
-    if (!params.consentClient) {
-      throw new Error('Consent client is required');
-    }
-    // Privacy center endpoints use JWT Bearer tokens, not session-based auth
-    const baseRequest = buildBaseRequest(params.organizationId, params.workspaceId, params.authToken);
-
-    // Ledger mode routes to the Go ledger's submit-consent (partial), which
-    // resolves on 2xx and throws otherwise — a resolved call is success (the
-    // ledger returns a ConsentEventResponse, no `success` flag). Legacy mode
-    // hits the Python manage-consent endpoint, whose unwrapped response
-    // carries a `success` flag that must be honored even on 2xx.
-    const result = await params.consentClient.manageConsent(
-      baseRequest,
-      params.purposeId,
-      params.contact,
-      params.action,
-      params.authToken,
-      undefined,
-      params.nominatorContact,
-      params.dataElementUuids,
-      params.productUuid,
-      params.noticeUuid,
-      params.dataElements,
-      params.language
-    );
-    if (result && typeof result === 'object' && 'success' in result) {
-      return Boolean((result as LegacyManageConsentResponse).success);
-    }
-    return true;
-  } catch (error: any) {
-    // Normalize nominator-specific errors into stable error codes
-    const errorMsg = error?.message || '';
-    if (errorMsg.includes('nominator_not_found')) {
-      throw new ConsentApiError('NOMINATOR_NOT_FOUND', errorMsg);
-    }
-    if (errorMsg.includes('nominee_must_specify_nominator')) {
-      throw new ConsentApiError('NOMINEE_MUST_SPECIFY_NOMINATOR', errorMsg);
-    }
-    return handleServerActionError(error, `${params.action} consent`);
-  }
-}
-
-export async function fetchActivitiesServer(params: {
-  organizationId: string;
-  workspaceId: string;
-  offset?: number;
-  limit?: number;
-  language?: string;
-  authToken?: string;
-  consentClient?: ReturnType<typeof import('./client').createConsentClient>;
-}): Promise<ActivityDetail | null> {
-  try {
-    if (!params.consentClient) {
-      throw new Error('Consent client is required');
-    }
-
-    // Privacy center endpoints use JWT Bearer tokens, not session-based auth
-    const baseRequest = buildBaseRequest(params.organizationId, params.workspaceId, params.authToken);
-
-    const result = await params.consentClient.getActivities(
-      baseRequest,
-      params.offset,
-      params.limit,
-      params.language,
-      params.authToken
-    );
-    return result as ActivityDetail;
-  } catch (error: any) {
-    return handleServerActionError(error, 'fetching activities');
-  }
-}
-
-export async function fetchReceiptsServer(params: {
-  organizationId: string;
-  workspaceId: string;
-  skip?: number;
-  limit?: number;
-  notice_uuid?: string;
-  event_type?: string;
-  status?: string;
-  created_after?: string;
-  created_before?: string;
-  language?: string;
-  authToken?: string;
-  consentClient?: ReturnType<typeof import('./client').createConsentClient>;
-}): Promise<unknown | null> {
-  try {
-    if (!params.consentClient) {
-      throw new Error('Consent client is required');
-    }
-    // Privacy center endpoints use JWT Bearer tokens, not session-based auth
-    const baseRequest = buildBaseRequest(params.organizationId, params.workspaceId, params.authToken);
-
-    const result = await params.consentClient.getReceipts(
-      baseRequest,
-      {
-        skip: params.skip,
-        limit: params.limit,
-        notice_uuid: params.notice_uuid,
-        event_type: params.event_type,
-        status: params.status,
-        created_after: params.created_after,
-        created_before: params.created_before,
-        language: params.language,
-      },
-      params.authToken
-    );
-    return result;
-  } catch (error: any) {
-    return handleServerActionError(error, 'fetching receipts');
-  }
-}
-
-export async function fetchReceiptPdfServer(params: {
-  organizationId: string;
-  workspaceId: string;
-  receiptUuid: string;
-  authToken?: string;
-  consentClient?: ReturnType<typeof import('./client').createConsentClient>;
-}): Promise<Blob | null> {
-  try {
-    if (!params.consentClient) {
-      throw new Error('Consent client is required');
-    }
-    const baseRequest = buildBaseRequest(params.organizationId, params.workspaceId, params.authToken);
-
-    const result = await params.consentClient.getReceiptPdf(
-      baseRequest,
-      params.receiptUuid,
-      params.authToken
-    );
-    return result;
-  } catch (error: any) {
-    // Re-throw 404s (receipt doesn't exist or not yours) so the UI can show a targeted message
-    return handleServerActionError(error, 'downloading receipt PDF', true);
-  }
-}
-
-export async function fetchCaseHistoryServer(params: {
-  organizationId: string;
-  workspaceId: string;
-  contact: string;
-  offset?: number;
-  limit?: number;
-  language?: string;
-  authToken?: string;
-  consentClient?: ReturnType<typeof import('./client').createConsentClient>;
-}): Promise<CaseHistoryDetail | null> {
-  try {
-    if (!params.consentClient) {
-      throw new Error('Consent client is required');
-    }
-    // Privacy center endpoints use JWT Bearer tokens, not session-based auth
-    const baseRequest = buildBaseRequest(params.organizationId, params.workspaceId, params.authToken);
-
-    const result = await params.consentClient.getCaseHistory(
-      baseRequest,
-      params.contact,
-      params.offset,
-      params.limit,
-      params.language,
-      params.authToken
-    );
-
-    if (Array.isArray(result)) {
-      return {
-        data: result,
-        pagination: {
-          total_count: result.length,
-          offset: params.offset || 0,
-          limit: params.limit || 10
-        },
-      } as CaseHistoryDetail;
-    }
-
-    if (result && typeof result === 'object' && 'data' in result) {
-      const resultData = result as { data?: unknown[]; pagination?: Pagination };
-      return {
-        data: resultData.data || [],
-        pagination: resultData.pagination || {
-          total_count: resultData.data?.length || 0,
-          offset: params.offset || 0,
-          limit: params.limit || 10
-        },
-      } as CaseHistoryDetail;
-    }
-
-    return {
-      data: [],
-      pagination: {
-        total_count: 0,
-        offset: params.offset || 0,
-        limit: params.limit || 10
-      },
-    } as CaseHistoryDetail;
-  } catch (error: any) {
-    return handleServerActionError(error, 'fetching case history');
-  }
-}
-
-// ─── Case Communication ──────────────────────────────────────────────────────
-
-type ConsentClient = NonNullable<CaseActionBaseParams['consentClient']>;
-
-async function runCaseAction<T>(
-  params: CaseActionBaseParams,
-  label: string,
-  fn: (client: ConsentClient, baseRequest: BaseRequest) => Promise<T>
-): Promise<T | null> {
-  try {
-    if (!params.consentClient) throw new Error('Consent client is required');
-    const baseRequest = buildBaseRequest(params.organizationId, params.workspaceId, params.authToken);
-    return await fn(params.consentClient, baseRequest);
-  } catch (error: any) {
-    return handleServerActionError(error, label);
-  }
-}
-
-export async function getCaseMessagesServer(params: GetCaseMessagesParams): Promise<CaseMessage[] | null> {
-  return runCaseAction(params, 'fetching case messages', (client, base) =>
-    client.getCaseMessages(base, params.caseUuid, params.authToken)
-  );
-}
-
-export async function sendCaseMessageServer(params: SendCaseMessageParams): Promise<CaseMessage | null> {
-  return runCaseAction(params, 'sending case message', (client, base) =>
-    client.sendCaseMessage(base, params.caseUuid, params.body, params.documentUuids, params.authToken)
-  );
-}
-
-export async function uploadCaseDocumentServer(params: UploadCaseDocumentParams): Promise<UploadDocumentResponse | null> {
-  return runCaseAction(params, 'uploading case document', (client, base) =>
-    client.uploadCaseDocument(base, params.caseUuid, params.file, params.authToken)
-  );
-}
-
-export async function submitDocumentForRequestServer(params: SubmitDocumentForRequestParams): Promise<CaseMessage | null> {
-  return runCaseAction(params, 'submitting document for request', (client, base) =>
-    client.submitDocumentForRequest(base, params.caseUuid, params.requestEventUuid, params.documentUuid, params.body, params.authToken)
-  );
-}
-
-export async function getCaseDocumentServer(params: GetCaseDocumentParams): Promise<MessageDocument | null> {
-  return runCaseAction(params, 'fetching case document', (client, base) =>
-    client.getCaseDocument(base, params.caseUuid, params.documentUuid, params.authToken)
-  );
-}
-
-// ─── Notification Hub ───────────────────────────────────────────────────────
-
-
-
-async function runNotificationAction<T>(
-  params: NotificationActionBaseParams,
-  label: string,
-  fn: (client: NotificationClient, baseRequest: BaseRequest) => Promise<T>
-): Promise<T | null> {
-  try {
-    if (!params.consentClient) {
-      throw new Error('Consent client is required')
-    }
-    const baseRequest = buildBaseRequest(params.organizationId, params.workspaceId, params.authToken);
-    return await fn(params.consentClient, baseRequest);
-  } catch (error) {
-    return handleServerActionError(error, label);
-  }
-}
-
-export async function getNotificationsServer(
-  params: GetNotificationsServerParams
-): Promise<NotificationListResponse | null> {
-  return runNotificationAction(params, 'fetching notifications', (client, base) =>
-    client.getNotifications(base, {
-      category: params.category,
-      notification_type: params.notification_type,
-      is_read: params.is_read,
-      skip: params.skip,
-      limit: params.limit,
-      include_summary: params.include_summary,
-      language: params.language,
-    }, params.authToken)
-  );
-}
-
-export async function getNotificationSummaryServer(
-  params: NotificationActionBaseParams
-): Promise<NotificationSummary | null> {
-  return runNotificationAction(params, 'fetching notification summary', (client, base) =>
-    client.getNotificationSummary(base, params.authToken)
-  );
-}
-
-export async function getUnreadCountServer(
-  params: NotificationActionBaseParams
-): Promise<UnreadCountResponse | null> {
-  return runNotificationAction(params, 'fetching unread count', (client, base) =>
-    client.getUnreadCount(base, params.authToken)
-  );
-}
-
-export async function markNotificationReadServer(
-  params: NotificationByUuidServerParams
-): Promise<NotificationActionResponse | null> {
-  return runNotificationAction(params, 'marking notification as read', (client, base) =>
-    client.markNotificationRead(base, params.notificationUuid, params.authToken)
-  );
-}
-
-export async function markAllNotificationsReadServer(
-  params: NotificationActionBaseParams
-): Promise<NotificationActionResponse | null> {
-  return runNotificationAction(params, 'marking all notifications as read', (client, base) =>
-    client.markAllNotificationsRead(base, params.authToken)
-  );
-}
-
-export async function acknowledgeNotificationServer(
-  params: NotificationByUuidServerParams
-): Promise<NotificationActionResponse | null> {
-  return runNotificationAction(params, 'acknowledging notification', (client, base) =>
-    client.acknowledgeNotification(base, params.notificationUuid, params.authToken)
-  );
-}