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

package/src/RedactoPrivacyCenter/api/actions.ts

@@ -0,0 +1,476 @@
+import type { BaseRequest } from './client';
+
+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,
+  OtpResponse,
+  OtpVerificationResponse,
+  Pagination,
+  SendCaseMessageParams,
+  SubmitDocumentForRequestParams,
+  TokenExchangeResponse,
+  UploadCaseDocumentParams,
+  UploadDocumentResponse,
+  UserConsentDetail,
+} 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) {
+    // Check if this is an expired refresh token error (expected scenario)
+    const errorMessage = error?.message || '';
+    const isExpiredTokenError =
+      errorMessage.includes('expired') ||
+      errorMessage.includes('Invalid refresh token') ||
+      errorMessage.includes('Refresh token') ||
+      errorMessage.includes('revoked');
+
+    // For expired/revoked tokens, return null gracefully (don't log as error)
+    if (isExpiredTokenError) {
+      return null;
+    }
+
+    // For other errors (network, etc.), log and re-throw
+    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;
+  contact: string;
+  offset?: number;
+  limit?: 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,
+      params.contact,
+      params.offset,
+      params.limit,
+      params.search,
+      params.status,
+      params.product_uuid,
+      params.language,
+      params.authToken
+    );
+
+    return result as UserConsentDetail;
+  } catch (error: any) {
+    return handleServerActionError(error, 'fetching user consents');
+  }
+}
+
+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[];
+}): 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);
+
+    const result = await params.consentClient.manageConsent(
+      baseRequest,
+      params.purposeId,
+      params.contact,
+      params.action,
+      params.authToken,
+      undefined,
+      params.nominatorContact,
+      params.dataElementUuids
+    );
+    return (result as { success: boolean })?.success ?? null;
+  } 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 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)
+  );
+}