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

package/src/shared/api-errors.ts

@@ -1,180 +0,0 @@
-/**
- * Shared API error handling for the consent-sdk-react package.
- *
- * The backend (consent-server) owns the user-facing copy. Each error
- * response carries:
- *   - `message`: user-safe text the SDK displays verbatim
- *   - `error_code`: stable identifier for programmatic branching
- *
- * The SDK never re-translates a code into a message. To change wording,
- * update the server titles registry -- no SDK release required.
- */
-
-export type ApiErrorCode =
-  | "INVALID_TOKEN"
-  | "TOKEN_TENANT_MISMATCH"
-  | "UNAUTHORIZED"
-  | "USER_NOT_FOUND"
-  | "USER_EMAIL_MISMATCH"
-  | "USER_MOBILE_MISMATCH"
-  | "USER_CONTACT_MISMATCH"
-  | "NO_IDENTIFIER_PROVIDED"
-  | "INVALID_PAYLOAD"
-  | "VALIDATION_ERROR"
-  | "NOTICE_NOT_FOUND"
-  | "NOTICE_CONFIGURATION_NOT_FOUND"
-  | "NOTICE_STILL_IN_DRAFT"
-  | "CONSENT_ALREADY_PROVIDED"
-  | "PURPOSE_NOT_FOUND"
-  | "INVALID_PURPOSE"
-  | "INVALID_DATA_ELEMENTS"
-  | "MISSING_PURPOSE"
-  | "MISSING_DATA_ELEMENTS"
-  | "REQUIRED_DATA_ELEMENT_NOT_ENABLED"
-  | "AUDIO_NOT_FOUND"
-  | "INVALID_LANGUAGE"
-  | "VERIFICATION_FAILED"
-  | "VERIFICATION_EXPIRED"
-  | "GUARDIAN_INFO_NOT_FOUND"
-  | "GUARDIAN_SESSION_INVALID"
-  | "SESSION_EXPIRED"
-  | "INTERNAL_ERROR";
-
-interface ApiErrorDetail {
-  message?: string;
-  error_code?: string | null;
-  // Ninja's auth-pipeline auto-401 returns `{detail: {detail: "Unauthorized"}}`
-  // -- the inner `detail` is a string. Captured here so the parser can use
-  // it as a last-resort message extraction.
-  detail?: string;
-}
-
-interface ApiErrorBody {
-  message?: string;
-  error_code?: string | null;
-  // Some endpoints (e.g. OTP verify) signal "this code is dead, request a fresh
-  // one" via a top-level boolean instead of an `error_code`. Captured so callers
-  // can branch on it (e.g. to distinguish an expired code from a wrong one).
-  should_request_new?: boolean;
-  // `detail` may arrive as:
-  //   { message: "...", error_code: "..." }    -- our MessageResponse via Ninja
-  //   { detail: "..." }                         -- Ninja auto-401
-  //   "..."                                     -- direct string from some endpoints
-  //   [...]                                     -- Ninja auto-422 Pydantic errors
-  detail?: ApiErrorDetail | string | unknown[];
-}
-
-// `ApiErrorCode | (string & {})` keeps literal autocomplete on `code` while
-// still permitting unknown strings from forward-compatible server versions.
-// A bare `ApiErrorCode | string` would widen to `string` and lose the
-// literal suggestions.
-export type ApiErrorCodeLike = ApiErrorCode | (string & {});
-
-export class ApiError extends Error {
-  readonly status: number;
-  readonly code?: ApiErrorCodeLike;
-  // Mirrors the server's `should_request_new` flag, when present.
-  readonly shouldRequestNew?: boolean;
-
-  constructor(opts: {
-    status: number;
-    code?: ApiErrorCodeLike;
-    message: string;
-    shouldRequestNew?: boolean;
-  }) {
-    super(opts.message);
-    this.name = "ApiError";
-    this.status = opts.status;
-    this.code = opts.code;
-    this.shouldRequestNew = opts.shouldRequestNew;
-  }
-}
-
-// Tier-3 fallbacks for failure modes where the server did not produce
-// a parseable body with `message`. Common case: Ninja's auth pipeline
-// rejects a request before reaching our handler, returning
-// `{detail: {detail: "Unauthorized"}}` with no message field. The
-// fallback is a static, user-safe hint -- never an override of a
-// server-supplied message.
-function statusFallback(status: number): string | undefined {
-  if (status === 401) {
-    return "Your session has expired. Please request a new access link.";
-  }
-  if (status === 403) {
-    return "You do not have access to this resource.";
-  }
-  if (status >= 500) {
-    return "Something went wrong on our end. Please try again later.";
-  }
-  return undefined;
-}
-
-/**
- * Build an ApiError from a non-OK fetch Response.
- *
- * Order of preference for the user-facing message:
- *   1. `message` field from the backend response body (preferred -- the
- *      SDK-consumed endpoints always populate this with user-safe copy).
- *   2. Status-based fallback (only when the server omitted a message,
- *      e.g. Ninja's auto-401 for an expired JWT).
- *   3. The caller-supplied fallback (used when the body is missing or
- *      unparseable -- network error, non-JSON proxy page).
- *
- * The `code` field is exposed as-is for programmatic branching. Consumers
- * that want compile-time safety should narrow against `ApiErrorCode`.
- */
-function extractFromDetail(
-  detail: ApiErrorBody["detail"]
-): { message?: string; code?: string | null } {
-  // String detail (e.g. some endpoints return `{detail: "..."}` directly).
-  if (typeof detail === "string") {
-    return { message: detail };
-  }
-  // Array detail (Ninja's auto-422 Pydantic validation errors): no usable
-  // single message; let the caller fall back to status/generic copy.
-  if (Array.isArray(detail)) {
-    return {};
-  }
-  // Object detail covers both shapes:
-  //   our MessageResponse: { message, error_code }
-  //   Ninja auto-401:      { detail: "Unauthorized" }
-  if (detail && typeof detail === "object") {
-    const obj = detail as ApiErrorDetail;
-    return { message: obj.message ?? obj.detail, code: obj.error_code };
-  }
-  return {};
-}
-
-export async function parseApiError(
-  response: Response,
-  fallbackMessage: string
-): Promise<ApiError> {
-  let body: ApiErrorBody | undefined;
-  let parsedBody = false;
-  try {
-    body = (await response.json()) as ApiErrorBody;
-    parsedBody = true;
-  } catch {
-    body = undefined;
-  }
-
-  const fromDetail = extractFromDetail(body?.detail);
-  const serverMessage = body?.message ?? fromDetail.message;
-  // Status fallback only applies when the body parsed but had no message
-  // (e.g. Ninja auto-401's `{detail: {detail: "Unauthorized"}}`). When the
-  // body is unparseable (proxy HTML 502, empty body, network jank) the
-  // caller's per-endpoint fallback is the more accurate hint -- a 401 from
-  // a misbehaving proxy is not necessarily an expired session.
-  const message =
-    serverMessage ??
-    (parsedBody ? statusFallback(response.status) : undefined) ??
-    fallbackMessage;
-  const code = body?.error_code ?? fromDetail.code ?? undefined;
-
-  return new ApiError({
-    status: response.status,
-    code,
-    message,
-    shouldRequestNew: body?.should_request_new,
-  });
-}

package/src/types/css.d.ts

@@ -1,4 +0,0 @@
-declare module "*.module.css" {
-  const classes: { [key: string]: string };
-  export default classes;
-}

package/src/types/images.d.ts

@@ -1,19 +0,0 @@
-declare module "*.png" {
-  const content: string;
-  export default content;
-}
-
-declare module "*.jpg" {
-  const content: string;
-  export default content;
-}
-
-declare module "*.jpeg" {
-  const content: string;
-  export default content;
-}
-
-declare module "*.svg" {
-  const content: string;
-  export default content;
-}

package/src/types/react-jsx.d.ts

@@ -1,26 +0,0 @@
-/**
- * React 19 JSX compatibility: ensures intrinsic elements (div, button, etc.)
- * and Element type align with React's types to fix "Element is not assignable to ReactNode".
- * @see https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/71395
- */
-import type React from "react";
-
-declare global {
-  namespace JSX {
-    type Element = React.ReactElement;
-  }
-}
-
-declare module "react/jsx-runtime" {
-  namespace JSX {
-    type Element = React.ReactElement;
-    interface IntrinsicElements extends React.JSX.IntrinsicElements {}
-  }
-}
-
-declare module "react/jsx-dev-runtime" {
-  namespace JSX {
-    type Element = React.ReactElement;
-    interface IntrinsicElements extends React.JSX.IntrinsicElements {}
-  }
-}

package/tests/DataAvailabilityContext.test.tsx

@@ -1,123 +0,0 @@
-import { render, screen, waitFor } from '@testing-library/react';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-// ─── API stubs ───────────────────────────────────────────────────────────────
-// The gate calls the direct fetchers (NOT react-query hooks). Each returns
-// `null` on error in production; we exercise both null and rejection paths.
-const fetchUserConsents = vi.fn();
-const fetchCaseHistory = vi.fn();
-const fetchActivities = vi.fn();
-vi.mock('../src/RedactoPrivacyCenter/lib/api', () => ({
-  fetchUserConsents: (...args: unknown[]) => fetchUserConsents(...args),
-  fetchCaseHistory: (...args: unknown[]) => fetchCaseHistory(...args),
-  fetchActivities: (...args: unknown[]) => fetchActivities(...args),
-}));
-
-// ─── Language stub (avoids subscribing to the real i18n event emitter) ───────
-vi.mock('../src/RedactoPrivacyCenter/lib/useCurrentLanguage', () => ({
-  useCurrentLanguage: () => ({ currentLanguage: 'en', langParam: undefined }),
-}));
-
-// ─── Auth / BaseUrl / Organization context stubs ─────────────────────────────
-vi.mock('../src/RedactoPrivacyCenter/context/AuthContext', () => {
-  const auth = {
-    accessToken: 'tok',
-    refreshToken: 'rtok',
-    onError: () => false,
-    updateTokens: () => {},
-  };
-  return { useAuth: () => auth };
-});
-vi.mock('../src/RedactoPrivacyCenter/context/BaseUrlContext', () => {
-  const base = { consentClient: {}, baseUrl: 'https://consent.test' };
-  return { useBaseUrl: () => base };
-});
-vi.mock('../src/RedactoPrivacyCenter/context/OrganizationContext', () => {
-  const org = {
-    organization: { uuid: 'org-uuid', slug: 'acme', name: 'Acme', workspaces: [{ uuid: 'ws-uuid' }] },
-  };
-  return { useOrganization: () => org };
-});
-
-import {
-  DataAvailabilityProvider,
-  useDataAvailability,
-} from '../src/RedactoPrivacyCenter/context/DataAvailabilityContext';
-
-const emptyConsents = { status_summary: { total_purposes: 0 }, direct: [], nominated: [], nominators: [] };
-const emptyCases = { data: [] };
-const emptyActivities = { pagination: { total_count: 0 } };
-
-function StatusProbe() {
-  const { status } = useDataAvailability();
-  return <div data-testid="status">{status}</div>;
-}
-
-function renderGate() {
-  return render(
-    <DataAvailabilityProvider>
-      <StatusProbe />
-    </DataAvailabilityProvider>,
-  );
-}
-
-const waitForStatus = (value: string) =>
-  waitFor(() => expect(screen.getByTestId('status').textContent).toBe(value));
-
-describe('DataAvailabilityContext', () => {
-  beforeEach(() => {
-    sessionStorage.setItem('email', 'user@example.com');
-    // Default: everything empty.
-    fetchUserConsents.mockResolvedValue(emptyConsents);
-    fetchCaseHistory.mockResolvedValue(emptyCases);
-    fetchActivities.mockResolvedValue(emptyActivities);
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-    sessionStorage.clear();
-  });
-
-  it("resolves to 'empty' only when consents, cases, and activity are all empty", async () => {
-    renderGate();
-    await waitForStatus('empty');
-  });
-
-  it("resolves to 'has-data' when there are consents", async () => {
-    fetchUserConsents.mockResolvedValue({ status_summary: { total_purposes: 2 }, direct: [{}], nominated: [], nominators: [] });
-    renderGate();
-    await waitForStatus('has-data');
-  });
-
-  it("resolves to 'has-data' when there are cases", async () => {
-    fetchCaseHistory.mockResolvedValue({ data: [{ uuid: 'c1' }] });
-    renderGate();
-    await waitForStatus('has-data');
-  });
-
-  it("resolves to 'has-data' when there is activity", async () => {
-    fetchActivities.mockResolvedValue({ pagination: { total_count: 4 } });
-    renderGate();
-    await waitForStatus('has-data');
-  });
-
-  it("fails open to 'has-data' when a signal returns null", async () => {
-    // Consents + cases empty, but activity could not be read (null).
-    fetchActivities.mockResolvedValue(null);
-    renderGate();
-    await waitForStatus('has-data');
-  });
-
-  it("fails open to 'has-data' when a signal rejects", async () => {
-    fetchUserConsents.mockRejectedValue(new Error('boom'));
-    renderGate();
-    await waitForStatus('has-data');
-  });
-
-  it("skips the cases fetch when no email is present, treating cases as empty", async () => {
-    sessionStorage.removeItem('email');
-    renderGate();
-    await waitForStatus('empty');
-    expect(fetchCaseHistory).not.toHaveBeenCalled();
-  });
-});