@redacto.io/consent-sdk-react 5.2.0 → 6.0.0

package/src/RedactoPrivacyCenter/api/actions.ts

@@ -22,15 +22,24 @@ import type {
   GetCaseDocumentParams,
   GetCaseMessagesParams,
   MessageDocument,
+  GetNotificationsServerParams,
+  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 {
@@ -258,9 +267,10 @@ export async function fetchProductsServer(params: {
 export async function fetchUserConsentsServer(params: {
   organizationId: string;
   workspaceId: string;
-  contact: string;
   offset?: number;
   limit?: number;
+  nominatedOffset?: number;
+  nominatedLimit?: number;
   search?: string;
   status?: string;
   product_uuid?: string;
@@ -277,13 +287,16 @@ export async function fetchUserConsentsServer(params: {
 
     const result = await params.consentClient.getUserConsents(
       baseRequest,
-      params.contact,
-      params.offset,
-      params.limit,
-      params.search,
-      params.status,
-      params.product_uuid,
-      params.language,
+      {
+        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
     );
 
@@ -293,6 +306,45 @@ export async function fetchUserConsentsServer(params: {
   }
 }
 
+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;
@@ -474,3 +526,79 @@ export async function getCaseDocumentServer(params: GetCaseDocumentParams): Prom
     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)
+  );
+}

package/src/RedactoPrivacyCenter/api/client.ts

@@ -3,6 +3,11 @@ import type { ApiFetchOptions, ApiResponse } from "./fetcher";
 import type {
   CaseMessage,
   MessageDocument,
+  NotificationActionResponse,
+  NotificationListResponse,
+  NotificationQueryParams,
+  NotificationSummary,
+  UnreadCountResponse,
   UploadDocumentResponse,
 } from "../lib/types";
 
@@ -157,6 +162,10 @@ export function createConsentClient(baseUrl: string) {
     return privacyCenterUrl(baseRequest, `/cases/${caseUuid}${path}`);
   }
 
+  function notificationUrl(baseRequest: BaseRequest, path = ''): string {
+    return privacyCenterUrl(baseRequest, `/notifications${path}`);
+  }
+
   function resolveAuthToken(authToken: string | undefined, baseRequest: BaseRequest): string {
     return authToken || baseRequest.authToken;
   }
@@ -329,29 +338,72 @@ export function createConsentClient(baseUrl: string) {
      */
     async getUserConsents(
       baseRequest: BaseRequest,
-      contact: string,
-      offset?: number,
-      limit?: number,
-      search?: string,
-      status?: string,
-      product_uuid?: string,
-      language?: string,
+      params: {
+        offset?: number;
+        limit?: number;
+        nominated_offset?: number;
+        nominated_limit?: number;
+        status?: string;
+        product_uuid?: string;
+        search?: string;
+        language?: string;
+      },
       authToken?: string,
       options?: Omit<ApiFetchOptions, "getAuthToken">
     ): Promise<unknown> {
       const queryParams = new URLSearchParams();
-      if (offset !== undefined) queryParams.append("offset", offset.toString());
-      if (limit !== undefined) queryParams.append("limit", limit.toString());
-      if (search) queryParams.append("search", search);
-      if (status) queryParams.append("status", status);
-      if (product_uuid) queryParams.append("product_uuid", product_uuid);
-      if (language) queryParams.append("language", language);
+      if (params.offset !== undefined) queryParams.append("offset", params.offset.toString());
+      if (params.limit !== undefined) queryParams.append("limit", params.limit.toString());
+      if (params.nominated_offset !== undefined) queryParams.append("nominated_offset", params.nominated_offset.toString());
+      if (params.nominated_limit !== undefined) queryParams.append("nominated_limit", params.nominated_limit.toString());
+      if (params.search) queryParams.append("search", params.search);
+      if (params.status) queryParams.append("status", params.status);
+      if (params.product_uuid) queryParams.append("product_uuid", params.product_uuid);
+      if (params.language) queryParams.append("language", params.language);
       const queryString = queryParams.toString();
       const url = privacyCenterUrl(baseRequest, `/user-consents${queryString ? `?${queryString}` : ""}`);
       return privacyCenterApiFetch(url, {
         ...options,
-        method: "POST",
-        body: JSON.stringify({ contact }),
+        method: "GET",
+        cache: "no-store",
+        authToken: resolveAuthToken(authToken, baseRequest),
+      });
+    },
+
+    /**
+     * Get purposes for a single product card (privacy center) — sister endpoint
+     * for lazy-loading purposes when a card returns has_more_purposes: true.
+     */
+    async getGroupPurposes(
+      baseRequest: BaseRequest,
+      productUuid: string,
+      params: {
+        offset?: number;
+        limit?: number;
+        status?: string;
+        search?: string;
+        language?: string;
+        nominator_uuid?: string;
+      },
+      authToken?: string,
+      options?: Omit<ApiFetchOptions, "getAuthToken">
+    ): Promise<unknown> {
+      const queryParams = new URLSearchParams();
+      if (params.offset !== undefined) queryParams.append("offset", params.offset.toString());
+      if (params.limit !== undefined) queryParams.append("limit", params.limit.toString());
+      if (params.status) queryParams.append("status", params.status);
+      if (params.search) queryParams.append("search", params.search);
+      if (params.language) queryParams.append("language", params.language);
+      if (params.nominator_uuid) queryParams.append("nominator_uuid", params.nominator_uuid);
+      const queryString = queryParams.toString();
+      const url = privacyCenterUrl(
+        baseRequest,
+        `/user-consents/${productUuid}/purposes${queryString ? `?${queryString}` : ""}`
+      );
+      return privacyCenterApiFetch(url, {
+        ...options,
+        method: "GET",
+        cache: "no-store",
         authToken: resolveAuthToken(authToken, baseRequest),
       });
     },
@@ -520,5 +572,114 @@ export function createConsentClient(baseUrl: string) {
         authToken: resolveAuthToken(authToken, baseRequest),
       });
     },
+
+    // ─── Notification Hub ─────────────────────────────────────────────────
+
+    /**
+     * List notifications (paginated, with filters)
+     */
+    async getNotifications(
+      baseRequest: BaseRequest,
+      params?: NotificationQueryParams,
+      authToken?: string
+    ): Promise<NotificationListResponse> {
+      const queryParams = new URLSearchParams();
+      if (params?.category) {
+        queryParams.append('category', params.category);
+      }
+      if (params?.notification_type) {
+        queryParams.append('notification_type', params.notification_type);
+      }
+      if (params?.is_read !== undefined) {
+        queryParams.append('is_read', String(params.is_read));
+      }
+      if (params?.skip !== undefined) {
+        queryParams.append('skip', params.skip.toString());
+      }
+      if (params?.limit !== undefined) {
+        queryParams.append('limit', params.limit.toString());
+      }
+      if (params?.include_summary) {
+        queryParams.append('include_summary', 'true');
+      }
+      if (params?.language) {
+        queryParams.append('language', params.language);
+      }
+      const queryString = queryParams.toString();
+      const url = notificationUrl(baseRequest, queryString ? `?${queryString}` : '');
+      return privacyCenterApiFetch<NotificationListResponse>(url, {
+        authToken: resolveAuthToken(authToken, baseRequest),
+      });
+    },
+
+    /**
+     * Get notification summary (aggregated counts only)
+     */
+    async getNotificationSummary(
+      baseRequest: BaseRequest,
+      authToken?: string
+    ): Promise<NotificationSummary> {
+      const url = notificationUrl(baseRequest, '/summary');
+      return privacyCenterApiFetch<NotificationSummary>(url, {
+        authToken: resolveAuthToken(authToken, baseRequest),
+      });
+    },
+
+    /**
+     * Get unread notification count (lightweight, for badge)
+     */
+    async getUnreadCount(
+      baseRequest: BaseRequest,
+      authToken?: string
+    ): Promise<UnreadCountResponse> {
+      const url = notificationUrl(baseRequest, '/unread-count');
+      return privacyCenterApiFetch<UnreadCountResponse>(url, {
+        authToken: resolveAuthToken(authToken, baseRequest),
+      });
+    },
+
+    /**
+     * Mark a single notification as read
+     */
+    async markNotificationRead(
+      baseRequest: BaseRequest,
+      notificationUuid: string,
+      authToken?: string
+    ): Promise<NotificationActionResponse> {
+      const url = notificationUrl(baseRequest, `/${notificationUuid}/read`);
+      return privacyCenterApiFetch<NotificationActionResponse>(url, {
+        method: 'PATCH',
+        authToken: resolveAuthToken(authToken, baseRequest),
+      });
+    },
+
+    /**
+     * Mark all notifications as read
+     */
+    async markAllNotificationsRead(
+      baseRequest: BaseRequest,
+      authToken?: string
+    ): Promise<NotificationActionResponse> {
+      const url = notificationUrl(baseRequest, '/mark-all-read');
+      return privacyCenterApiFetch<NotificationActionResponse>(url, {
+        method: 'POST',
+        authToken: resolveAuthToken(authToken, baseRequest),
+      });
+    },
+
+    /**
+     * Acknowledge a notification (sets is_read and is_acknowledged to true)
+     */
+    async acknowledgeNotification(
+      baseRequest: BaseRequest,
+      notificationUuid: string,
+      authToken?: string
+    ): Promise<NotificationActionResponse> {
+      const url = notificationUrl(baseRequest, `/${notificationUuid}/acknowledge`);
+      return privacyCenterApiFetch<NotificationActionResponse>(url, {
+        method: 'POST',
+        authToken: resolveAuthToken(authToken, baseRequest),
+      });
+    },
   };
 }