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

package/src/RedactoNoticeConsent/api/index.ts

@@ -1,512 +0,0 @@
-import { jwtDecode } from "jwt-decode";
-import { parseApiError } from "../../shared/api-errors";
-import type {
-  ConsentContent,
-  ConsentEventPayload,
-  DataElementSelection,
-  FetchConsentContentParams,
-  FetchTTSAudioUrlsParams,
-  InitiateGuardianVerificationParams,
-  InitiateGuardianVerificationResponse,
-  NoticeConsentStatusResponse,
-  PurposeSelection,
-  RedactoJwtPayload,
-  SubmitConsentEventParams,
-  TTSAudioUrlsResponse,
-  VerifyGuardianStatusParams,
-  VerifyGuardianStatusResponse,
-} from "./types";
-
-// The ledger `check-consent` read is shared with RedactoNoticeConsentInline.
-// Re-exported through this barrel so `./api` importers (and the test mock)
-// resolve it here unchanged.
-export { fetchNoticeConsentStatus } from "../../shared/notice-consent-status";
-
-const BASE_URL = "https://api.redacto.io/consent";
-
-// Simple in-memory cache for API responses to reduce calls
-const apiCache = new Map<string, { data: any; timestamp: number; ttl: number }>();
-const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
-
-// Utility function to get cached data
-function getCachedData(key: string): any | null {
-  const cached = apiCache.get(key);
-  if (cached && Date.now() - cached.timestamp < cached.ttl) {
-    return cached.data;
-  }
-  if (cached) {
-    apiCache.delete(key);
-  }
-  return null;
-}
-
-// Utility function to set cached data
-function setCachedData(key: string, data: any, ttl = CACHE_TTL): void {
-  apiCache.set(key, { data, timestamp: Date.now(), ttl });
-}
-
-// Utility function to decode JWT with error handling
-function decodeTokenSafely(token: string): RedactoJwtPayload | null {
-  try {
-    return jwtDecode(token) as RedactoJwtPayload;
-  } catch (error) {
-    console.warn("Failed to decode JWT token:", error);
-    return null;
-  }
-}
-
-// Function to clear API cache (useful for testing or when switching users)
-export const clearApiCache = (): void => {
-  apiCache.clear();
-};
-
-export const fetchConsentContent = async ({
-  noticeId,
-  accessToken,
-  baseUrl,
-  language = "en",
-  specific_uuid,
-  validate_against = "all",
-  include_fully_consented_data = false,
-  signal,
-}: FetchConsentContentParams & { signal?: AbortSignal }): Promise<ConsentContent> => {
-  if (!noticeId || !accessToken || !validate_against) {
-    throw new Error("noticeId and accessToken are required");
-  }
-
-  const decodedToken = decodeTokenSafely(accessToken);
-  if (!decodedToken) {
-    throw new Error("Invalid access token");
-  }
-
-  const { organisation_uuid: ORGANISATION_UUID, workspace_uuid: WORKSPACE_UUID } = decodedToken;
-  if (!ORGANISATION_UUID || !WORKSPACE_UUID) {
-    throw new Error("Invalid token: missing organization or workspace UUID");
-  }
-
-  const apiBaseUrl = baseUrl || BASE_URL;
-
-  // Create cache key for this request - include accessToken to ensure different users get different cache
-  const cacheKey = `${accessToken}-${noticeId}-${validate_against}-${language}-${specific_uuid || ''}-${include_fully_consented_data}`;
-
-  if (validate_against === "all" && !specific_uuid) {
-    const cachedData = getCachedData(cacheKey);
-    if (cachedData) {
-      return cachedData;
-    }
-  }
-
-  const url = new URL(
-    `${apiBaseUrl}/public/organisations/${ORGANISATION_UUID}/workspaces/${WORKSPACE_UUID}/notices/${noticeId}`
-  );
-
-  if (specific_uuid) {
-    url.searchParams.append("specific_uuid", specific_uuid);
-  }
-  url.searchParams.append("validate_against", validate_against);
-  if (include_fully_consented_data) {
-    url.searchParams.append("include_fully_consented_data", "true");
-  }
-
-  const response = await fetch(url.toString(), {
-    method: "GET",
-    headers: {
-      Authorization: `Bearer ${accessToken}`,
-      "Accept-Language": language,
-    },
-    signal,
-  });
-
-  if (!response.ok) {
-    throw await parseApiError(
-      response,
-      "Could not load the consent notice. Please try again."
-    );
-  }
-
-  const data: ConsentContent = await response.json();
-
-  if (validate_against === "all" && !specific_uuid) {
-    setCachedData(cacheKey, data);
-  }
-
-  return data;
-};
-
-export const submitConsentEvent = async ({
-  accessToken,
-  baseUrl,
-  ledgerBaseUrl,
-  noticeUuid,
-  purposes,
-  declined,
-  language,
-  meta_data,
-  guardianVerificationReference,
-  selfDeclaredAdult,
-  signal,
-}: SubmitConsentEventParams & { signal?: AbortSignal }): Promise<void> => {
-  if (!noticeUuid || !accessToken || !Array.isArray(purposes)) {
-    throw new Error("noticeUuid, accessToken, and purposes array are required");
-  }
-
-  const decodedToken = decodeTokenSafely(accessToken);
-  if (!decodedToken) {
-    throw new Error("Invalid access token");
-  }
-
-  const { organisation_uuid: ORGANISATION_UUID, workspace_uuid: WORKSPACE_UUID } = decodedToken;
-  if (!ORGANISATION_UUID || !WORKSPACE_UUID) {
-    throw new Error("Invalid token: missing organization or workspace UUID");
-  }
-
-  // Fall back to the consent server when no ledger is configured, so existing
-  // integrations that only pass baseUrl remain backwards compatible.
-  const apiBaseUrl = ledgerBaseUrl || baseUrl || BASE_URL;
-
-  const validatedPurposes = purposes.map((purpose) => {
-    if (!purpose.uuid) {
-      throw new Error(`Invalid purpose data: missing uuid`);
-    }
-
-    // Only include enabled data elements (disabled elements are not selectable)
-    const dataElements = (purpose.data_elements || [])
-      .filter((element) => element.enabled)
-      .map((element) => ({
-        uuid: element.uuid,
-        selected: element.required ? true : Boolean(element.selected),
-      }));
-
-    return {
-      purpose_uuid: purpose.uuid,
-      selected: Boolean(purpose.selected),
-      data_elements: dataElements.length > 0 ? dataElements : undefined,
-    };
-  });
-
-  const payload: ConsentEventPayload = {
-    notice_uuid: noticeUuid,
-    purposes: validatedPurposes,
-    select_all_mandatory: false,
-    source: "WEB",
-    declined: Boolean(declined),
-    language: language || undefined,
-    meta_data: meta_data ? { specific_uuid: meta_data.specific_uuid, minor_age: meta_data.minor_age } : undefined,
-    guardian_verification_reference: guardianVerificationReference,
-    self_declared_adult: selfDeclaredAdult,
-  };
-
-  const response = await fetch(
-    `${apiBaseUrl}/public/organisations/${ORGANISATION_UUID}/workspaces/${WORKSPACE_UUID}/submit-consent`,
-    {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${accessToken}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(payload),
-      signal,
-    }
-  );
-
-  if (!response.ok) {
-    throw await parseApiError(
-      response,
-      "Could not submit your consent. Please try again."
-    );
-  }
-
-  // Clear any cached consent content since user preferences have changed
-  apiCache.clear();
-};
-
-/**
- * Translate the ledger's notice consent status into the
- * `{ purpose_selections, reconsent_required }` shape the banner already
- * consumes, so prior-consent pre-fill and reconsent categorization work off
- * the ledger. Returns null for a first-time principal (no consent record —
- * every purpose INACTIVE), preserving the normal first-time consent flow.
- *
- * `needs_reconsent` is derived from `status` (anything not ACTIVE needs
- * reconsent: expired / withdrawn / declined / inactive). NOTE: notice-version
- * reconsent is NOT covered — the ledger's check-consent has no version
- * awareness yet, so a republished-notice version bump won't re-prompt until
- * that lands on the ledger (tracked fast-follow).
- */
-export const buildLedgerConsentOverlay = (
-  status: NoticeConsentStatusResponse,
-  configPurposes: ConsentContent["detail"]["active_config"]["purposes"]
-): {
-  reconsent_required: boolean;
-  purpose_selections: Record<string, PurposeSelection>;
-} | null => {
-  const byUuid = new Map(status.purposes.map((p) => [p.uuid, p]));
-  const hasHistory = status.purposes.some(
-    (p) => (p.status || "INACTIVE") !== "INACTIVE"
-  );
-  if (!hasHistory) {
-    return null;
-  }
-
-  const purpose_selections: Record<string, PurposeSelection> = {};
-  for (const cp of configPurposes) {
-    const lp = byUuid.get(cp.uuid);
-    const purposeStatus = lp?.status || "INACTIVE";
-    const selectedByUuid = new Map(
-      (lp?.data_elements || []).map((de) => [de.uuid, de.selected])
-    );
-    const data_elements: Record<string, DataElementSelection> = {};
-    for (const de of cp.data_elements) {
-      data_elements[de.uuid] = {
-        selected: selectedByUuid.get(de.uuid) ?? false,
-        enabled: de.enabled,
-        required: de.required,
-      };
-    }
-    purpose_selections[cp.uuid] = {
-      selected: lp?.selected ?? false,
-      status: purposeStatus,
-      needs_reconsent: purposeStatus !== "ACTIVE",
-      data_elements,
-    };
-  }
-
-  const reconsent_required = configPurposes.some(
-    (cp) => (purpose_selections[cp.uuid]?.status || "INACTIVE") !== "ACTIVE"
-  );
-  return { reconsent_required, purpose_selections };
-};
-
-export const fetchTTSAudioUrls = async ({
-  accessToken,
-  baseUrl,
-  noticeUuid,
-  language,
-  signal,
-}: FetchTTSAudioUrlsParams & { signal?: AbortSignal }): Promise<TTSAudioUrlsResponse> => {
-  if (!accessToken || !noticeUuid || !language) {
-    throw new Error("accessToken, noticeUuid, and language are required");
-  }
-
-  const decodedToken = decodeTokenSafely(accessToken);
-  if (!decodedToken) {
-    throw new Error("Invalid access token");
-  }
-
-  const { organisation_uuid: ORGANISATION_UUID, workspace_uuid: WORKSPACE_UUID } = decodedToken;
-  if (!ORGANISATION_UUID || !WORKSPACE_UUID) {
-    throw new Error("Invalid token: missing organization or workspace UUID");
-  }
-
-  const apiBaseUrl = baseUrl || BASE_URL;
-
-  const url = `${apiBaseUrl}/public/organisations/${ORGANISATION_UUID}/workspaces/${WORKSPACE_UUID}/notices/${noticeUuid}/audio/${language}`;
-
-  const response = await fetch(url, {
-    method: "GET",
-    headers: {
-      Authorization: `Bearer ${accessToken}`,
-      Accept: "application/json",
-    },
-    signal,
-  });
-
-  if (!response.ok) {
-    throw await parseApiError(
-      response,
-      "Could not load audio narration. Please try again."
-    );
-  }
-
-  const data: TTSAudioUrlsResponse = await response.json();
-  return data;
-};
-
-// =============================================================================
-// Guardian Verification API Functions
-// =============================================================================
-
-/**
- * Initiate guardian verification via DigiLocker
- * POST /guardian/initiate-verification
- * 
- * This combines guardian details submission and DigiLocker initiation in one call.
- */
-export const initiateGuardianVerification = async ({
-  accessToken,
-  baseUrl,
-  guardianName,
-  guardianContact,
-  guardianRelationship,
-  frontendCallbackUrl,
-  metadata,
-  signal,
-}: InitiateGuardianVerificationParams): Promise<InitiateGuardianVerificationResponse> => {
-  try {
-    if (!accessToken) {
-      throw new Error("accessToken is required");
-    }
-
-    if (!guardianName?.trim()) {
-      throw new Error("Guardian name is required");
-    }
-
-    if (!guardianContact?.trim()) {
-      throw new Error("Guardian contact is required");
-    }
-
-    if (!guardianRelationship?.trim()) {
-      throw new Error("Guardian relationship is required");
-    }
-
-    const decodedToken = decodeTokenSafely(accessToken);
-    if (!decodedToken) {
-      throw new Error("Invalid access token");
-    }
-
-    const { organisation_uuid: ORGANISATION_UUID, workspace_uuid: WORKSPACE_UUID } = decodedToken;
-    if (!ORGANISATION_UUID || !WORKSPACE_UUID) {
-      throw new Error("Invalid token: missing organization or workspace UUID");
-    }
-
-    const apiBaseUrl = baseUrl || BASE_URL;
-
-    const payload: {
-      guardian_name: string;
-      guardian_contact: string;
-      guardian_relationship: string;
-      frontend_callback_url?: string;
-      metadata?: Record<string, unknown>;
-    } = {
-      guardian_name: guardianName.trim(),
-      guardian_contact: guardianContact.trim(),
-      guardian_relationship: guardianRelationship.trim(),
-    };
-
-    if (frontendCallbackUrl) {
-      payload.frontend_callback_url = frontendCallbackUrl;
-    }
-
-    if (metadata) {
-      payload.metadata = metadata;
-    }
-
-    const response = await fetch(
-      `${apiBaseUrl}/public/organisations/${ORGANISATION_UUID}/workspaces/${WORKSPACE_UUID}/guardian/initiate-verification`,
-      {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${accessToken}`,
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify(payload),
-        signal,
-      }
-    );
-
-    if (!response.ok) {
-      throw await parseApiError(
-        response,
-        "Could not start guardian verification. Please try again."
-      );
-    }
-
-    const responseData = await response.json();
-
-    // Handle response with detail wrapper (backend format: { code, status, detail: {...} })
-    const detail = responseData.detail || responseData;
-
-    // Already verified — skip DigiLocker entirely
-    if (detail.already_verified) {
-      return {
-        success: true,
-        guardian_info_uuid: detail.guardian_info_uuid,
-        already_verified: true,
-        verification_reference: detail.verification_reference,
-      };
-    }
-
-    // New verification flow — needs DigiLocker
-    if (!detail.session_token || !detail.digilocker_redirect_url) {
-      throw new Error("Invalid response: missing session_token or digilocker_redirect_url");
-    }
-
-    return {
-      success: detail.success ?? true,
-      guardian_info_uuid: detail.guardian_info_uuid,
-      already_verified: false,
-      session_token: detail.session_token,
-      digilocker_redirect_url: detail.digilocker_redirect_url,
-      expires_at: detail.expires_at,
-    };
-  } catch (error) {
-    console.error("Error initiating guardian verification:", error instanceof Error ? error.message : error);
-    throw error;
-  }
-};
-
-/**
- * Check guardian verification status
- * POST /guardian/verify-status
- * 
- * Poll this endpoint to check if DigiLocker verification is complete.
- * Returns verification_reference when status is "verified".
- */
-export const verifyGuardianStatus = async ({
-  accessToken,
-  baseUrl,
-  sessionToken,
-  signal,
-}: VerifyGuardianStatusParams): Promise<VerifyGuardianStatusResponse> => {
-  if (!accessToken || !sessionToken) {
-    throw new Error("accessToken and sessionToken are required");
-  }
-
-  const decodedToken = decodeTokenSafely(accessToken);
-  if (!decodedToken) {
-    throw new Error("Invalid access token");
-  }
-
-  const { organisation_uuid: ORGANISATION_UUID, workspace_uuid: WORKSPACE_UUID } = decodedToken;
-  if (!ORGANISATION_UUID || !WORKSPACE_UUID) {
-    throw new Error("Invalid token: missing organization or workspace UUID");
-  }
-
-  const apiBaseUrl = baseUrl || BASE_URL;
-
-  const response = await fetch(
-    `${apiBaseUrl}/public/organisations/${ORGANISATION_UUID}/workspaces/${WORKSPACE_UUID}/guardian/verify-status`,
-    {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${accessToken}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        session_token: sessionToken,
-      }),
-      signal,
-    }
-  );
-
-  if (!response.ok) {
-    throw await parseApiError(
-      response,
-      "Could not check verification status. Please try again."
-    );
-  }
-
-  const responseData = await response.json();
-  const detail = responseData.detail || responseData;
-
-  return {
-    status: detail.status ?? "in_progress",
-    guardian_info_uuid: detail.guardian_info_uuid ?? null,
-    verification_reference: detail.verification_reference ?? null,
-    guardian_details: detail.guardian_details ?? null,
-    error: detail.error ?? null,
-    error_code: detail.error_code ?? null,
-    can_retry: detail.can_retry ?? true,
-  };
-};
-