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

package/src/RedactoPrivacyCenter/components/Form.tsx

@@ -11,11 +11,7 @@ import { toast } from '../utils/toast';
 import { PCButton, PCCheckbox, PCInput, PCLoader, PCSelect, PCText, PCTextarea } from '../ui';
 import { buildGroupDataElements, buildGroupPurposes } from './groupHelpers';
 import { pcStyles } from '../styles/pcStyles';
-import {
-  createCaseRequest,
-  createCaseRequestUnsafe,
-  getFormData,
-} from '../lib/api';
+import { createCaseRequest, getFormData } from '../lib/api';
 import { ensureValidToken } from '../lib/utils';
 import { useAuth } from '../context/AuthContext';
 import { useBaseUrl } from '../context/BaseUrlContext';
@@ -27,9 +23,7 @@ import { useOrganization } from '../context/OrganizationContext';
 import i18n from '../lib/i18n';
 import { getLangParam } from '../lib/useCurrentLanguage';
 import type {
-  BatchCaseSubmitResult,
   CreateCaseResponse,
-  DataElement,
   FormData,
   FormProductGroup,
   GrievanceOptions,
@@ -72,22 +66,33 @@ type ExtractedCaseRef = { uuid: string; case_id: string };
 type CaseIdContainer = { case_id?: string; uuid?: string };
 
 /**
- * Request types that engage the Phase 2 product-step + per-product picker.
- * Nomination and grievance are org-level and skip the product step.
- *
- * ACCESS/ERASURE drive a per-product `PurposeSelectionSection`; CORRECTION
- * drives a per-product `CorrectionDataSection` whose `dataElements` are
- * scoped to the selected group (dedup within product, not across products).
+ * Request types that engage the per-product picker and require a
+ * product anchor (`product_uuid`) on the submitted case. Nomination
+ * and grievance are org-level and skip the product step entirely.
  */
-const GROUPED_REQUEST_TYPES: ReadonlySet<RequestTypeEnum> = new Set([
+const PRODUCT_SCOPED_REQUEST_TYPES: ReadonlySet<RequestTypeEnum> = new Set([
   RequestTypeEnum.ACCESS,
   RequestTypeEnum.ERASURE,
   RequestTypeEnum.CORRECTION,
 ]);
 
-const isGroupedRequestType = (
+const isProductScopedRequestType = (
   rt: RequestTypeEnum | null,
-): rt is RequestTypeEnum => rt !== null && GROUPED_REQUEST_TYPES.has(rt);
+): rt is RequestTypeEnum =>
+  rt !== null && PRODUCT_SCOPED_REQUEST_TYPES.has(rt);
+
+/**
+ * Result shape rendered by RequestSubmit after a successful submission.
+ * Product fields are populated only for product-scoped request types
+ * (ACCESS / ERASURE / CORRECTION); nomination and grievance leave them
+ * as empty strings so the success card omits the product label.
+ */
+type SubmittedCase = {
+  case_id: string;
+  uuid: string;
+  product_name: string;
+  product_uuid: string;
+};
 
 /**
  * Pull the `case_id` out of a `createCaseRequest` response, handling both
@@ -158,60 +163,39 @@ export default function Form({
     additionalNote: '',
     confirmCheckBox: false,
   });
-  const [erasurePurposes, setErasurePurposes] = useState<Purpose[]>([]);
-  const [accessPurposes, setAccessPurposes] = useState<Purpose[]>([]);
-  // Phase 2 of TECH-3712. Set of product-group keys the user has selected on
-  // the new product-cards step. Keyed by `productGroupKey(group)` so a single
-  // product reached both directly and via a nominator stays distinct.
+  // Selected product-group key on the product-cards step. Keyed by
+  // `productGroupKey(group)` so the same product reached both directly
+  // AND via a nominator stays addressable as two distinct selections.
+  // null when no product is selected (or for org-level request types).
   const [selectedProductKey, setSelectedProductKey] = useState<string | null>(
     null,
   );
-  // Phase 2 of TECH-3712. Per-product purpose state keyed by
-  // `productGroupKey(group)`. Each selected group keeps its own Purpose[]
-  // for the existing PurposeSelectionSection to drive.
-  const [purposesByGroupKey, setPurposesByGroupKey] = useState<
-    Map<string, Purpose[]>
-  >(new Map());
+  // Purpose state for the currently-selected product group. Seeded from
+  // `buildGroupPurposes(group)` whenever `selectedProductKey` changes, then
+  // mutated in place by `PurposeSelectionSection` as the user picks
+  // purposes / data elements. Single-select means we never need a Map.
+  const [selectedPurposes, setSelectedPurposes] = useState<Purpose[]>([]);
+  // CORRECTION selections for the currently-selected product group. These
+  // are flat (not keyed by product) because the picker is single-select —
+  // switching products re-seeds them via the same effect that re-seeds
+  // `selectedPurposes`. Names are the data-element names visible in the
+  // UI; they're reverse-translated to English at submit time.
   const [selectedCorrectionElements, setSelectedCorrectionElements] = useState<
     string[]
   >([]);
-  const [uniqueDataElements, setUniqueDataElements] = useState<DataElement[]>(
-    []
-  );
   const [correctionValues, setCorrectionValues] = useState<
     Record<string, { current: string; updated: string }>
   >({});
-  // TECH-3712 (correction grouped path). Per-product correction selections
-  // keyed by `productGroupKey(group)`. Parallel to `purposesByGroupKey`
-  // for ACCESS/ERASURE — each selected group keeps its own list of chosen
-  // data-element names and the {current, updated} value pairs for them.
-  const [correctionElementsByGroupKey, setCorrectionElementsByGroupKey] =
-    useState<Map<string, string[]>>(new Map());
-  const [correctionValuesByGroupKey, setCorrectionValuesByGroupKey] = useState<
-    Map<string, Record<string, { current: string; updated: string }>>
-  >(new Map());
-  // P2-SDK-4 of TECH-3712. Holds the aggregated batch result that
-  // `RequestSubmit` renders on the success step. Both paths populate this:
-  //   - Grouped DSAR: directly from `submitBatchCases`.
-  //   - Legacy single-case: a synthetic single-entry result.
-  const [batchResult, setBatchResult] = useState<BatchCaseSubmitResult | null>(
+  // Result rendered by `RequestSubmit` after a successful submission.
+  // Replaces the prior batch-shape now that submit is 1-form / 1-case.
+  // Product fields are empty strings for nomination / grievance (no
+  // product anchor) so the success card omits the product label.
+  const [submittedCase, setSubmittedCase] = useState<SubmittedCase | null>(
     null,
   );
-  // P2-SDK-4 of TECH-3712. Product-group keys currently mid-retry. Drives
-  // the per-row spinner state on the failure list. Keyed by
-  // `productGroupKey(group)` (not `product_uuid`) so a product picked both
-  // directly and via a nominator can be retried independently.
-  const [retryingGroupKeys, setRetryingGroupKeys] = useState<Set<string>>(
-    new Set(),
-  );
   const fileInputRef = useRef<HTMLInputElement>(null);
   // Store the original English form data for submission — translations are display-only
   const englishDataRef = useRef<FormData | null>(null);
-  // Store selections to restore after translation
-  const selectionsToRestoreRef = useRef<{
-    access: Map<string, { purposeSelected: boolean; dataElementSelections: Map<string, boolean> }>;
-    erasure: Map<string, { purposeSelected: boolean; dataElementSelections: Map<string, boolean> }>;
-  } | null>(null);
   const [uploadedDocumentId, setUploadedDocumentId] = useState<string[]>([]);
   const [uploadedDocuments, setUploadedDocuments] = useState<
     { uuid: string; name: string }[]
@@ -242,73 +226,41 @@ export default function Form({
     }
   };
 
-  // Phase 2 of TECH-3712. Backwards-compat guard: the new grouped flow only
-  // engages when the backend ships the `direct_groups` field (Phase 1). Older
-  // backends fall through to the legacy flat-purposes render below.
-  const useGroupedRender = useMemo<boolean>(
-    () => Array.isArray(data?.direct_groups),
-    [data],
-  );
-
-  // Phase 2 of TECH-3712. Surface a one-time warning per data load when we
-  // fall back to the legacy flat-purposes render. Helps customer developers
-  // notice their backend hasn't been upgraded to Phase 1 yet (the form still
-  // works, but the new product-scoped DSAR UX is unavailable).
-  useEffect(() => {
-    if (data && !useGroupedRender) {
-      console.warn(
-        '[consent-sdk] Backend response lacks direct_groups; ' +
-          'falling back to legacy flat-purposes render. ' +
-          'Update consent-server to Phase 1 to enable product-scoped DSAR.',
-      );
-    }
-  }, [data, useGroupedRender]);
-
-  // Phase 2 of TECH-3712. Union of direct + nominated product groups used to
-  // drive both the cards step and the per-product purpose-picker step.
+  // Union of direct + nominated product groups exposed by the backend.
+  // Drives both the product-cards step and the per-product picker beneath.
   const allGroups = useMemo<FormProductGroup[]>(() => {
-    if (!useGroupedRender || !data) {
+    if (!data) {
       return [];
     }
     return [...(data.direct_groups ?? []), ...(data.nominated_groups ?? [])];
-  }, [data, useGroupedRender]);
+  }, [data]);
 
   // TECH-3712 UX: when the DP has exactly one consent group total
   // (direct + nominated combined), the product-selection step is friction —
   // there's nothing to choose. Skip rendering ProductSelectionSection
-  // entirely and auto-select the lone group below so step 3 (per-product
-  // purpose picker) renders without an intermediate card. With zero groups
-  // we still render the section so the empty-state message is visible.
-  const totalGroups = useMemo<number>(
-    () =>
-      (data?.direct_groups?.length ?? 0) +
-      (data?.nominated_groups?.length ?? 0),
-    [data],
-  );
-  const skipProductStep = totalGroups === 1;
-
-  // Phase 2 of TECH-3712. Subset of groups currently checked on the cards
-  // step — drives which `PurposeSelectionSection`s render and which cases
-  // get POSTed on submit.
-  const selectedGroups = useMemo<FormProductGroup[]>(() => {
+  // entirely and auto-select the lone group below so the per-product
+  // picker renders without an intermediate card. With zero groups we
+  // still render the section so the empty-state message is visible.
+  const skipProductStep = allGroups.length === 1;
+
+  // The single product-group the user is currently working with. Null
+  // when no product is selected (the picker is shown empty / unselected)
+  // or when the request type is org-level (nomination / grievance).
+  const selectedGroup = useMemo<FormProductGroup | null>(() => {
     if (selectedProductKey) {
-      const group = allGroups.find(
-        (g) => productGroupKey(g) === selectedProductKey,
+      return (
+        allGroups.find((g) => productGroupKey(g) === selectedProductKey) ??
+        null
       );
-      if (group) {
-        return [group];
-      }
     }
     if (skipProductStep) {
-      const onlyGroup =
-        data?.direct_groups?.[0] ?? data?.nominated_groups?.[0];
-      return onlyGroup ? [onlyGroup] : [];
+      return allGroups[0] ?? null;
     }
-    return [];
-  }, [allGroups, selectedProductKey, skipProductStep, data]);
+    return null;
+  }, [allGroups, selectedProductKey, skipProductStep]);
 
-  // Phase 2 of TECH-3712. Stable select handler for ProductSelectionSection.
-  // Single-group auto-select fires this on mount via the child's effect.
+  // Stable select handler for ProductSelectionSection. Single-group
+  // auto-select fires this on mount via the child's effect.
   const handleProductSelect = useCallback(
     (key: string | null, _group: FormProductGroup | null) => {
       setSelectedProductKey(key);
@@ -316,120 +268,6 @@ export default function Form({
     [],
   );
 
-  // Phase 2 of TECH-3712. Stable per-group setter passed to the wrapped
-  // PurposeSelectionSection so each card edits its own slice of state.
-  const setPurposesForGroup = useCallback(
-    (key: string, updated: Purpose[]) => {
-      setPurposesByGroupKey((prev) => {
-        const next = new Map(prev);
-        next.set(key, updated);
-        return next;
-      });
-    },
-    [],
-  );
-
-  // TECH-3712 (correction grouped path). Stable per-group setters for the
-  // CORRECTION maps. CorrectionDataSection's `setSelected` and
-  // `setCorrectionValues` props are value-setters (not state updaters), so
-  // these accept the full replacement value the child computed.
-  const setCorrectionElementsForGroup = useCallback(
-    (key: string, values: string[]) => {
-      setCorrectionElementsByGroupKey((prev) => {
-        const next = new Map(prev);
-        next.set(key, values);
-        return next;
-      });
-    },
-    [],
-  );
-
-  const setCorrectionValuesForGroup = useCallback(
-    (
-      key: string,
-      values: Record<string, { current: string; updated: string }>,
-    ) => {
-      setCorrectionValuesByGroupKey((prev) => {
-        const next = new Map(prev);
-        next.set(key, values);
-        return next;
-      });
-    },
-    [],
-  );
-
-  useEffect(() => {
-    if (data?.purposes) {
-      // Validate purposes array structure
-      if (!Array.isArray(data.purposes)) {
-        console.warn('Form data purposes is not an array:', data.purposes);
-        return;
-      }
-
-      const extractedPurposes = data.purposes
-        .map((p) => p?.purpose)
-        .filter((p) => p !== null && p !== undefined);
-
-      if (extractedPurposes.length === 0) {
-        console.warn('No valid purposes found in form data');
-        return;
-      }
-
-      const uniqueElements = new Map();
-      extractedPurposes.forEach((purpose) => {
-        // Ensure data_elements is an array and filter out any null/undefined elements.
-        // Include every data element the org holds for this user, regardless of current
-        // consent state. Revoking consent does not delete data (TECH-4089), so purposes
-        // with revoked/withdrawn consent must remain raisable for access/erasure/correction.
-        const validDataElements = Array.isArray(purpose.data_elements)
-          ? purpose.data_elements.filter(
-            (element) => element !== null && element !== undefined && element.uuid
-          )
-          : [];
-
-        // Data elements are validated and processed
-
-        validDataElements.forEach((element) => {
-          if (element.uuid && !uniqueElements.has(element.uuid)) {
-            uniqueElements.set(element.uuid, {
-              ...element,
-              purposeName: purpose.name,
-            });
-          }
-        });
-      });
-
-      setUniqueDataElements(
-        Array.from(uniqueElements.values()) as DataElement[]
-      );
-
-      // Ensure data_elements are properly preserved with all properties.
-      // Include data elements regardless of consent state (revocation ≠ deletion,
-      // TECH-4089); only drop purposes that genuinely have no data elements.
-      const processedPurposes = extractedPurposes
-        .map((p) => {
-          const validDataElements = Array.isArray(p.data_elements)
-            ? p.data_elements
-              .filter((de) => de !== null && de !== undefined && de.uuid)
-              .map((de) => ({
-                ...de,
-                selected: false,
-              }))
-            : [];
-
-          return {
-            ...p,
-            selected: false,
-            data_elements: validDataElements,
-          };
-        })
-        .filter((p) => p.data_elements.length > 0);
-
-      setAccessPurposes(processedPurposes);
-      setErasurePurposes(processedPurposes);
-    }
-  }, [data]);
-
   const fetchAndApplyTranslations = useCallback(async (langValue: string) => {
     if (!organizationId || !workspaceId || !data) {
       return;
@@ -462,37 +300,6 @@ export default function Form({
         return;
       }
 
-      const currentAccessSelections = new Map<string, {
-        purposeSelected: boolean;
-        dataElementSelections: Map<string, boolean>;
-      }>();
-      const currentErasureSelections = new Map<string, {
-        purposeSelected: boolean;
-        dataElementSelections: Map<string, boolean>;
-      }>();
-
-      accessPurposes.forEach((purpose) => {
-        const dataElementSelections = new Map<string, boolean>();
-        purpose.data_elements.forEach((de) => {
-          dataElementSelections.set(de.uuid, de.selected);
-        });
-        currentAccessSelections.set(purpose.uuid, {
-          purposeSelected: purpose.selected,
-          dataElementSelections,
-        });
-      });
-
-      erasurePurposes.forEach((purpose) => {
-        const dataElementSelections = new Map<string, boolean>();
-        purpose.data_elements.forEach((de) => {
-          dataElementSelections.set(de.uuid, de.selected);
-        });
-        currentErasureSelections.set(purpose.uuid, {
-          purposeSelected: purpose.selected,
-          dataElementSelections,
-        });
-      });
-
       if (!translatedFormData.purposes ||
         !Array.isArray(translatedFormData.purposes) ||
         translatedFormData.purposes.length === 0) {
@@ -513,11 +320,6 @@ export default function Form({
         });
         setSelectedGrievances(updatedGrievanceSelections);
       }
-
-      selectionsToRestoreRef.current = {
-        access: currentAccessSelections,
-        erasure: currentErasureSelections,
-      };
     } catch (error) {
       console.error('Error fetching translation:', error);
       // Fallback to English when translation API fails
@@ -525,155 +327,71 @@ export default function Form({
     } finally {
       setIsTranslating(false);
     }
-  }, [organizationId, workspaceId, data, formData.contact, isPopup, isCaseManagementContext, authContext, consentClient, accessPurposes, erasurePurposes, selectedGrievances, t]);
-
-  // Clear previous selections when request type changes
+  }, [organizationId, workspaceId, data, formData.contact, isPopup, isCaseManagementContext, authContext, consentClient, selectedGrievances, t]);
+
+  // Clear product / org-level selections when request type changes.
+  // Per-product state (selectedPurposes, selectedCorrectionElements,
+  // correctionValues) is owned by the seed effect below — clearing it
+  // here too would race with that effect's re-seed when skipProductStep
+  // is true (the sole group stays selected across request-type changes
+  // because the auto-select effect refires on requestType).
   useEffect(() => {
-    setSelectedCorrectionElements([]);
-    setCorrectionValues({});
+    if (!skipProductStep) {
+      setSelectedProductKey(null);
+    }
     setNominationData({ nominee_email: '', nominee_mobile: '' });
-    // Phase 2 of TECH-3712. Drop product-step state too so switching from
-    // access to erasure (or back) starts the cards step from scratch.
-    setSelectedProductKey(null);
-    setPurposesByGroupKey(new Map());
-    // TECH-3712 (correction grouped path). Drop the per-group correction
-    // maps too so switching into/out of CORRECTION doesn't carry stale
-    // selections from a previous request-type pick.
-    setCorrectionElementsByGroupKey(new Map());
-    setCorrectionValuesByGroupKey(new Map());
-    if (data?.purposes && Array.isArray(data.purposes)) {
-      const extractedPurposes = data.purposes
-        .map((p) => p?.purpose)
-        .filter((p) => p !== null && p !== undefined);
-
-      // Ensure data_elements are properly preserved with all properties.
-      // Include data elements regardless of consent state (revocation ≠ deletion,
-      // TECH-4089); only drop purposes that genuinely have no data elements.
-      const processedPurposes = extractedPurposes
-        .map((p) => {
-          const validDataElements = Array.isArray(p.data_elements)
-            ? p.data_elements
-              .filter((de) => de !== null && de !== undefined && de.uuid)
-              .map((de) => ({
-                ...de,
-                selected: false,
-              }))
-            : [];
-
-          return {
-            ...p,
-            selected: false,
-            data_elements: validDataElements,
-          };
-        })
-        .filter((p) => p.data_elements.length > 0);
-
-      setAccessPurposes(processedPurposes);
-      setErasurePurposes(processedPurposes);
-
-      if (
-        requestType === RequestTypeEnum.GRIEVANCE &&
-        grievanceOptions.length > 0
-      ) {
-        const resetGrievances = grievanceOptions.reduce(
-          (acc, option) => {
-            acc[option.value] = false;
-            return acc;
-          },
-          {} as Record<string, boolean>
-        );
-        setSelectedGrievances(resetGrievances);
-      }
+
+    if (
+      requestType === RequestTypeEnum.GRIEVANCE &&
+      grievanceOptions.length > 0
+    ) {
+      const resetGrievances = grievanceOptions.reduce(
+        (acc, option) => {
+          acc[option.value] = false;
+          return acc;
+        },
+        {} as Record<string, boolean>,
+      );
+      setSelectedGrievances(resetGrievances);
     }
-  }, [requestType, data, grievanceOptions]);
-
-  // TECH-3712 UX: when `skipProductStep` is true (DP has exactly one consent
-  // group total), auto-select that group so step 3 (per-product purpose
-  // picker) renders directly without the user clicking a card. Placed AFTER
-  // the request-type-change clearing effect above so a request-type switch
-  // re-establishes the selection on the next tick — without this ordering,
-  // the clearing effect would wipe whatever this set on the same render.
-  // The child ProductSelectionSection has an equivalent mount-time effect,
-  // but that effect never fires here because the child is not rendered
-  // (see the JSX gate below).
+  }, [requestType, grievanceOptions, skipProductStep]);
+
+  // TECH-3712 UX: when `skipProductStep` is true (DP has exactly one
+  // consent group total), auto-select that group so the per-product
+  // picker renders directly without the user clicking a card. Placed
+  // AFTER the request-type-change clearing effect above so a request-type
+  // switch re-establishes the selection on the next tick. The child
+  // ProductSelectionSection has an equivalent mount-time effect, but
+  // that effect never fires here because the child is not rendered.
   useEffect(() => {
     if (!skipProductStep) {
       return;
     }
-    const onlyGroup =
-      data?.direct_groups?.[0] ?? data?.nominated_groups?.[0];
+    const onlyGroup = allGroups[0];
     if (!onlyGroup) {
       return;
     }
     const key = productGroupKey(onlyGroup);
     setSelectedProductKey((prev) => (prev === key ? prev : key));
-  }, [skipProductStep, data, requestType]);
-
-  // Phase 2 of TECH-3712. Initialise purpose state for newly-selected groups
-  // and prune entries for groups that have been deselected. Idempotent — only
-  // mutates when the keyset actually changes. Declared AFTER the request-type
-  // clearing effect so a type switch doesn't wipe freshly seeded entries.
-  useEffect(() => {
-    setPurposesByGroupKey((prev) => {
-      const next = new Map(prev);
-      const selectedKeys = new Set<string>();
-      for (const group of selectedGroups) {
-        const key = productGroupKey(group);
-        selectedKeys.add(key);
-        if (!next.has(key)) {
-          next.set(key, buildGroupPurposes(group));
-        }
-      }
-      for (const existingKey of Array.from(next.keys())) {
-        if (!selectedKeys.has(existingKey)) {
-          next.delete(existingKey);
-        }
-      }
-      return next;
-    });
-  }, [selectedGroups]);
-
-  // TECH-3712 (correction grouped path). Mirror the purpose-state effect
-  // for the CORRECTION per-group maps: seed empty slices for newly-selected
-  // groups and prune slices for deselected ones. Empty defaults keep the
-  // CorrectionDataSection signature unchanged (it expects a `string[]` and
-  // a `Record<string, {current, updated}>`).
+  }, [skipProductStep, allGroups, requestType]);
+
+  // Seed (and re-seed on product switch or request-type switch) the
+  // purpose / correction state from the currently-selected group.
+  // Single-select means one re-seed per product change — no Map
+  // reconciliation needed. Clears selections entirely when the user
+  // de-selects the chip (selectedGroup -> null) or when the request
+  // type switches into NOMINATION / GRIEVANCE.
   useEffect(() => {
-    setCorrectionElementsByGroupKey((prev) => {
-      const next = new Map(prev);
-      const selectedKeys = new Set<string>();
-      for (const group of selectedGroups) {
-        const key = productGroupKey(group);
-        selectedKeys.add(key);
-        if (!next.has(key)) {
-          next.set(key, []);
-        }
-      }
-      for (const existingKey of Array.from(next.keys())) {
-        if (!selectedKeys.has(existingKey)) {
-          next.delete(existingKey);
-        }
-      }
-      return next;
-    });
-    setCorrectionValuesByGroupKey((prev) => {
-      const next = new Map(prev);
-      const selectedKeys = new Set<string>();
-      for (const group of selectedGroups) {
-        const key = productGroupKey(group);
-        selectedKeys.add(key);
-        if (!next.has(key)) {
-          next.set(key, {});
-        }
-      }
-      for (const existingKey of Array.from(next.keys())) {
-        if (!selectedKeys.has(existingKey)) {
-          next.delete(existingKey);
-        }
-      }
-      return next;
-    });
-  }, [selectedGroups]);
+    if (!selectedGroup || !isProductScopedRequestType(requestType)) {
+      setSelectedPurposes([]);
+      setSelectedCorrectionElements([]);
+      setCorrectionValues({});
+      return;
+    }
+    setSelectedPurposes(buildGroupPurposes(selectedGroup));
+    setSelectedCorrectionElements([]);
+    setCorrectionValues({});
+  }, [selectedGroup, requestType]);
 
 
   // Fetch API translations when language changes (purposes, data elements, grievance options)
@@ -823,56 +541,41 @@ export default function Form({
     if (!isFormValid) {
       return;
     }
-    void handleSubmit(false);
+    // For ERASURE, set revoke_consent_on_fulfilment=true so the
+    // backend's auto-revoke task fires when the case is fulfilled.
+    // Erasing data without revoking the consent that authorized its
+    // processing is incoherent per DPDPA Sec 12. Other request types
+    // (ACCESS / CORRECTION / NOMINATION / GRIEVANCE) do not engage
+    // the auto-revoke path on the backend and pass false here.
+    void handleSubmit(requestType === RequestTypeEnum.ERASURE);
   };
 
+  /**
+   * Submit the form as a single case. Builds the payload from the
+   * currently-selected product group (for ACCESS/ERASURE/CORRECTION) or
+   * from the org-level state (for NOMINATION/GRIEVANCE), then POSTs once
+   * via `createCaseRequest`. The 1-form -> 1-case rule means no
+   * fan-out and no partial-failure UI to maintain.
+   *
+   * Anchors:
+   *   - `product_uuid` is set ONLY for product-scoped request types and
+   *     ONLY from `selectedGroup.product_uuid`. NOMINATION/GRIEVANCE
+   *     never carry a product anchor.
+   *   - `data_principal_uuid` is set ONLY for nominated cards (acting
+   *     on someone else's behalf — the nominator's ConsentUser uuid).
+   *     Direct cards omit the field so the backend defaults it from
+   *     the JWT-derived requestor_uuid. `formData.uuid` is the
+   *     FormDataOut session uuid, NOT the requestor's ConsentUser uuid,
+   *     and would be rejected by the backend's ConsentUser lookup.
+   */
   const handleSubmit = async (revokeConsent: boolean = false) => {
     if (!isFormValid) {
       return;
     }
 
-    // Phase 2 of TECH-3712. Multi-product DSAR batch path: fan one
-    // createCaseRequest per selected product via Promise.allSettled so
-    // partial failures don't tank the whole submission.
-    if (useGroupedRender && isGroupedRequestType(requestType) && selectedGroups.length > 0) {
-      try {
-        setIsLoading(true);
-        const result = await submitBatchCases(revokeConsent);
-
-        if (result.succeeded.length > 0) {
-          queryClient.invalidateQueries({ queryKey: ['caseHistory'] });
-          // P2-SDK-4 of TECH-3712. Thread the full BatchCaseSubmitResult
-          // through to RequestSubmit so the success surface can list every
-          // case_id and render per-card retry buttons for any failures.
-          setBatchResult(result);
-          setIsSubmitted(true);
-          if (result.failed.length === 0) {
-            toast.success(t('requestSubmittedSuccess'));
-          } else {
-            toast.error(t('requestSubmissionFailed'));
-          }
-          if (isPopup) {
-            onCreateRequest?.();
-          }
-        } else {
-          toast.error(t('requestSubmissionFailed'));
-        }
-      } catch (error) {
-        console.error('Error submitting batch request:', error);
-        toast.error(t('submissionFailed'));
-      } finally {
-        setIsLoading(false);
-        if (isPopup) {
-          onClose?.();
-        }
-      }
-      return;
-    }
+    const isProductScoped = isProductScopedRequestType(requestType);
+    const anchorGroup = isProductScoped ? selectedGroup : null;
 
-    // Legacy / non-DSAR path: a single createCaseRequest with org-level
-    // request_details. Untouched by Phase 2 — nomination and grievance are
-    // always org-level, and DSAR falls here only when the backend hasn't
-    // shipped Phase 1 yet (useGroupedRender === false).
     const requestDetails: {
       purposes: UpdatePurpose[];
       correction_data: UpdateCorrectionDataItem[];
@@ -884,19 +587,11 @@ export default function Form({
       grievance_types: [],
     };
 
-    if (requestType === RequestTypeEnum.ACCESS) {
-      requestDetails.purposes = accessPurposes
-        .filter((p) => p.selected || p.data_elements.some((de) => de.selected))
-        .map((p) => ({
-          purpose_uuid: p.uuid,
-          data_element_uuids: p.data_elements
-            .filter((de) => de.selected)
-            .map((de) => de.uuid),
-        }));
-    }
-
-    if (requestType === RequestTypeEnum.ERASURE) {
-      requestDetails.purposes = erasurePurposes
+    if (
+      requestType === RequestTypeEnum.ACCESS ||
+      requestType === RequestTypeEnum.ERASURE
+    ) {
+      requestDetails.purposes = selectedPurposes
         .filter((p) => p.selected || p.data_elements.some((de) => de.selected))
         .map((p) => ({
           purpose_uuid: p.uuid,
@@ -910,9 +605,9 @@ export default function Form({
       requestDetails.correction_data = selectedCorrectionElements.map(
         (name) => ({
           name: getEnglishDataElementName(name),
-          curr_value: correctionValues[name]?.current || '',
-          new_value: correctionValues[name]?.updated || '',
-        })
+          curr_value: correctionValues[name]?.current ?? '',
+          new_value: correctionValues[name]?.updated ?? '',
+        }),
       );
     }
 
@@ -948,6 +643,10 @@ export default function Form({
       ...(requestType === RequestTypeEnum.ERASURE
         ? { revoke_consent_on_fulfilment: revokeConsent }
         : {}),
+      ...(anchorGroup ? { product_uuid: anchorGroup.product_uuid } : {}),
+      ...(anchorGroup?.nominator
+        ? { data_principal_uuid: anchorGroup.nominator.uuid }
+        : {}),
     };
 
     try {
@@ -959,44 +658,28 @@ export default function Form({
         isPopup,
         isCaseManagementContext, // Use session auth if in case management context
         authContext,
-        consentClient
+        consentClient,
       );
       const extracted = extractCaseId(response);
       const caseId = extracted?.case_id || extracted?.uuid || null;
 
       if (caseId) {
         queryClient.invalidateQueries({ queryKey: ['caseHistory'] });
-        // P2-SDK-4 of TECH-3712. Wrap the lone response in a synthetic
-        // BatchCaseSubmitResult so RequestSubmit can render this path with
-        // the same UI it uses for the grouped batch path. When the grouped
-        // flow auto-selects a single product card we hydrate the synthetic
-        // entry with that product's identity so the success surface can
-        // render a product label alongside the case ID; otherwise we fall
-        // back to empty strings (legacy nomination/grievance/non-grouped
-        // DSAR have no product context to render).
-        const productInfo =
-          useGroupedRender && selectedGroups.length === 1
-            ? {
-                group_key: productGroupKey(selectedGroups[0]),
-                product_uuid: selectedGroups[0].product_uuid,
-                product_name: selectedGroups[0].product_name,
-              }
-            : { group_key: '', product_uuid: '', product_name: '' };
-        setBatchResult({
-          succeeded: [
-            {
-              ...productInfo,
-              case_id: caseId,
-              uuid: extracted?.uuid ?? caseId,
-            },
-          ],
-          failed: [],
+        setSubmittedCase({
+          case_id: caseId,
+          uuid: extracted?.uuid ?? caseId,
+          product_name: anchorGroup?.product_name ?? '',
+          product_uuid: anchorGroup?.product_uuid ?? '',
         });
         setIsSubmitted(true);
         toast.success(t('requestSubmittedSuccess'));
 
         if (isPopup) {
           onCreateRequest?.();
+          // Only dismiss the popup on success. Closing in `finally`
+          // would discard the operator's filled form on a transient
+          // failure with no way to retry.
+          onClose?.();
         }
       } else {
         toast.error(t('requestSubmissionFailed'));
@@ -1005,8 +688,7 @@ export default function Form({
       // `createCaseRequest` returns null on non-auth errors (per its
       // documented contract) — those land in the `else` branch above
       // with a generic toast. This catch only fires on unexpected
-      // exceptions further up the legacy code path; surface whatever
-      // message the error carries.
+      // exceptions; surface whatever message the error carries.
       console.error('Error submitting request:', error);
       const message =
         error instanceof Error && error.message
@@ -1015,363 +697,68 @@ export default function Form({
       toast.error(message);
     } finally {
       setIsLoading(false);
-      if (isPopup) {
-        onClose?.();
-      }
     }
   };
 
-  /**
-   * Phase 2 of TECH-3712. Single-product POST shared by `submitBatchCases`
-   * and `handleRetry` (P2-SDK-4). Builds the per-group payload (anchors,
-   * purposes, principal) and invokes `createCaseRequest`. The caller is
-   * responsible for catching/aggregating errors — this helper either
-   * resolves with the response or throws.
-   *
-   * Anchors per group:
-   *   - `product_uuid` from the group.
-   *   - `data_principal_uuid` is set ONLY for nominated cards (the
-   *     requestor is acting on someone else's behalf — the nominator's
-   *     ConsentUser uuid). For direct cards we omit the field entirely
-   *     so the backend defaults it from `requestor_uuid` (derived from
-   *     the JWT). `formData.uuid` here is the FormDataOut session uuid,
-   *     NOT the requestor's ConsentUser uuid, and would be rejected by
-   *     the backend's ConsentUser lookup.
-   */
-  const submitSingleProductCase = async (
-    group: FormProductGroup,
-    revokeConsent: boolean,
-  ): Promise<CreateCaseResponse | null> => {
-    const groupKey = productGroupKey(group);
-
-    // ACCESS/ERASURE per-group purposes. Empty for CORRECTION — that path
-    // populates `correction_data` below instead.
-    const groupPurposes = purposesByGroupKey.get(groupKey) ?? [];
-    const purposesPayload: UpdatePurpose[] =
-      requestType === RequestTypeEnum.CORRECTION
-        ? []
-        : groupPurposes
-            .filter(
-              (p) =>
-                p.selected || p.data_elements.some((de) => de.selected),
-            )
-            .map((p) => ({
-              purpose_uuid: p.uuid,
-              data_element_uuids: p.data_elements
-                .filter((de) => de.selected)
-                .map((de) => de.uuid),
-            }));
-
-    // TECH-3712 (correction grouped path). Per-group correction items: map
-    // each selected element name to its {current, updated} pair. Names are
-    // reverse-translated back to English via `getEnglishDataElementName`
-    // so the backend always receives the canonical attribute name even
-    // when the UI is showing a translated label.
-    const groupSelectedNames =
-      requestType === RequestTypeEnum.CORRECTION
-        ? correctionElementsByGroupKey.get(groupKey) ?? []
-        : [];
-    const groupValues =
-      requestType === RequestTypeEnum.CORRECTION
-        ? correctionValuesByGroupKey.get(groupKey) ?? {}
-        : {};
-    const correctionPayload: UpdateCorrectionDataItem[] =
-      requestType === RequestTypeEnum.CORRECTION
-        ? groupSelectedNames.map((name) => ({
-            name: getEnglishDataElementName(name),
-            curr_value: groupValues[name]?.current ?? '',
-            new_value: groupValues[name]?.updated ?? '',
-          }))
-        : [];
-
-    const payload: UserDataRequest = {
-      name: ' ',
-      contact: formData.contact,
-      request_type: requestType?.toLowerCase() as RequestTypeEnum,
-      uuid: formData.uuid,
-      supporting_docs_uuids: [...uploadedDocumentId],
-      request_details: {
-        purposes: purposesPayload,
-        correction_data: correctionPayload,
-        grievance_types: [],
-      },
-      time_period:
-        requestType === RequestTypeEnum.ACCESS
-          ? parseInt(timePeriod || '30', 10)
-          : 0,
-      requestor_note: formData.additionalNote || '',
-      ...(requestType === RequestTypeEnum.ERASURE
-        ? { revoke_consent_on_fulfilment: revokeConsent }
-        : {}),
-      product_uuid: group.product_uuid,
-      // Only set data_principal_uuid for nominee-driven cases. Direct
-      // cards default server-side to the JWT-derived requestor_uuid.
-      ...(group.nominator
-        ? { data_principal_uuid: group.nominator.uuid }
-        : {}),
-    };
-
-    // Use the "unsafe" variant in the batch path so non-auth errors throw
-    // instead of being swallowed to null — `Promise.allSettled` upstream
-    // catches them and surfaces the backend message (e.g. `[400]
-    // invalid_data_principal`) in `failed[].error` for that row.
-    return await createCaseRequestUnsafe(
-      organizationId || '',
-      workspaceId || '',
-      payload,
-      isPopup,
-      isCaseManagementContext,
-      authContext,
-      consentClient,
-    );
-  };
-
-  /**
-   * Phase 2 of TECH-3712. Fan one `createCaseRequestUnsafe` per selected
-   * product group via `Promise.allSettled`, aggregate into
-   * `BatchCaseSubmitResult`.
-   */
-  const submitBatchCases = async (
-    revokeConsent: boolean,
-  ): Promise<BatchCaseSubmitResult> => {
-    const submissions = selectedGroups.map((group) =>
-      submitSingleProductCase(group, revokeConsent).then(
-        (response) => ({ group, response }),
-      ),
-    );
-
-    const results = await Promise.allSettled(submissions);
-    const batchResult: BatchCaseSubmitResult = { succeeded: [], failed: [] };
-
-    results.forEach((result, idx) => {
-      const group = selectedGroups[idx];
-      const groupKey = productGroupKey(group);
-      if (result.status === 'fulfilled') {
-        const extracted = extractCaseId(result.value.response);
-        if (extracted && (extracted.case_id || extracted.uuid)) {
-          batchResult.succeeded.push({
-            group_key: groupKey,
-            product_uuid: group.product_uuid,
-            product_name: group.product_name,
-            case_id: extracted.case_id || extracted.uuid,
-            uuid: extracted.uuid || extracted.case_id,
-          });
-        } else {
-          batchResult.failed.push({
-            group_key: groupKey,
-            product_uuid: group.product_uuid,
-            product_name: group.product_name,
-            error: t('requestSubmissionFailed'),
-          });
-        }
-      } else {
-        const reason = result.reason;
-        const message =
-          reason instanceof Error
-            ? reason.message
-            : typeof reason === 'string'
-              ? reason
-              : t('submissionFailed');
-        batchResult.failed.push({
-          group_key: groupKey,
-          product_uuid: group.product_uuid,
-          product_name: group.product_name,
-          error: message,
-        });
-      }
-    });
-
-    return batchResult;
-  };
-
-  /**
-   * P2-SDK-4 of TECH-3712. Re-issue a single POST for one product-group
-   * that previously failed in the batch. On success, promote the entry
-   * from `batchResult.failed` to `batchResult.succeeded` so the UI can
-   * update in place. On failure, refresh the recorded error message so
-   * the user can try again.
-   *
-   * Keyed by `productGroupKey(group)` — NOT `product_uuid` — so that a
-   * product picked both directly AND via a nominator (two distinct
-   * groups with the same `product_uuid`) retries the right entry. No-op
-   * for the legacy single-case path (which has no group context to
-   * retry against — failures there don't land on this surface; they
-   * short-circuit before `setIsSubmitted`).
-   */
-  const handleRetry = useCallback(
-    async (groupKey: string) => {
-      if (groupKey === '') {
-        return;
-      }
-      const group = selectedGroups.find(
-        (g) => productGroupKey(g) === groupKey,
-      );
-      if (!group) {
-        return;
-      }
-
-      setRetryingGroupKeys((prev) => {
-        const next = new Set(prev);
-        next.add(groupKey);
-        return next;
-      });
-
-      try {
-        const response = await submitSingleProductCase(group, false);
-        const extracted = extractCaseId(response);
-        if (extracted && (extracted.case_id || extracted.uuid)) {
-          queryClient.invalidateQueries({ queryKey: ['caseHistory'] });
-          setBatchResult((prev) => {
-            if (!prev) {
-              return prev;
-            }
-            return {
-              succeeded: [
-                ...prev.succeeded,
-                {
-                  group_key: groupKey,
-                  product_uuid: group.product_uuid,
-                  product_name: group.product_name,
-                  case_id: extracted.case_id || extracted.uuid,
-                  uuid: extracted.uuid || extracted.case_id,
-                },
-              ],
-              failed: prev.failed.filter((f) => f.group_key !== groupKey),
-            };
-          });
-          toast.success(t('requestSubmittedSuccess'));
-        } else {
-          setBatchResult((prev) => {
-            if (!prev) {
-              return prev;
-            }
-            return {
-              succeeded: prev.succeeded,
-              failed: prev.failed.map((f) =>
-                f.group_key === groupKey
-                  ? { ...f, error: t('requestSubmissionFailed') }
-                  : f,
-              ),
-            };
-          });
-        }
-      } catch (error) {
-        const message =
-          error instanceof Error ? error.message : t('submissionFailed');
-        setBatchResult((prev) => {
-          if (!prev) {
-            return prev;
-          }
-          return {
-            succeeded: prev.succeeded,
-            failed: prev.failed.map((f) =>
-              f.group_key === groupKey ? { ...f, error: message } : f,
-            ),
-          };
-        });
-      } finally {
-        setRetryingGroupKeys((prev) => {
-          const next = new Set(prev);
-          next.delete(groupKey);
-          return next;
-        });
-      }
-    },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [
-      selectedGroups,
-      queryClient,
-      t,
-      // submitSingleProductCase closes over many form-state values; we
-      // intentionally don't list it to avoid identity churn re-rendering
-      // RequestSubmit while a retry is in flight.
-    ],
-  );
-
   const isRequestDetailsValid = useCallback(() => {
     if (!requestType) {
       return false;
     }
 
-    // Phase 2 of TECH-3712. Grouped DSAR validity: at least one product
-    // selected, and EVERY selected group has at least one purpose/data
-    // element chosen. The batch path fires one POST per selected group
-    // (Promise.allSettled), so a partially-filled card would either
-    // produce an empty `purposes` / `correction_data` payload that the
-    // backend rejects, or land as a no-op case. Require completeness
-    // across all selected groups before allowing submit.
-    if (useGroupedRender && isGroupedRequestType(requestType)) {
-      if (selectedGroups.length === 0) {
+    // Product-anchor validity gate: ACCESS/ERASURE/CORRECTION require a
+    // selected product before submit is allowed. The backend leaves
+    // `product_uuid` Optional for back-compat, so we enforce the anchor
+    // on the client — a product-scoped case without an anchor would
+    // land as an org-level case with no scoping, which violates the
+    // 1-form -> 1-case -> 1-product contract.
+    if (isProductScopedRequestType(requestType)) {
+      if (allGroups.length === 0) {
+        // No consent groups for this DP at all — the picker shows its
+        // empty state and we block submit. The DP has nothing they can
+        // raise a product-scoped case against.
         return false;
       }
-      if (requestType === RequestTypeEnum.CORRECTION) {
-        // For CORRECTION every selected group must have at least one
-        // chosen data element AND every chosen element must carry both
-        // current and updated values.
-        return selectedGroups.every((group) => {
-          const key = productGroupKey(group);
-          const selected = correctionElementsByGroupKey.get(key) ?? [];
-          const values = correctionValuesByGroupKey.get(key) ?? {};
-          return (
-            selected.length > 0 &&
-            selected.every(
-              (name) =>
-                values[name]?.current?.trim() &&
-                values[name]?.updated?.trim(),
-            )
-          );
-        });
+      if (!selectedGroup) {
+        // Groups exist but the user hasn't picked one. With the
+        // single-group auto-select effect this should be rare in
+        // practice, but the gate must still reject.
+        return false;
       }
-      return selectedGroups.every((group) => {
-        const purposes = purposesByGroupKey.get(productGroupKey(group)) ?? [];
-        return purposes.some(
-          (p) => p.selected || p.data_elements.some((de) => de.selected),
-        );
-      });
-    }
-
-    switch (requestType) {
-      case RequestTypeEnum.ACCESS:
-        return accessPurposes.some(
-          (p) => p.selected || p.data_elements.some((de) => de.selected)
-        );
-
-      case RequestTypeEnum.ERASURE:
-        return erasurePurposes.some(
-          (p) => p.selected || p.data_elements.some((de) => de.selected)
-        );
-
-      case RequestTypeEnum.GRIEVANCE:
-        return Object.values(selectedGrievances).some(Boolean);
-
-      case RequestTypeEnum.CORRECTION:
+      if (requestType === RequestTypeEnum.CORRECTION) {
         return (
           selectedCorrectionElements.length > 0 &&
           selectedCorrectionElements.every(
             (name) =>
               correctionValues[name]?.current?.trim() &&
-              correctionValues[name]?.updated?.trim()
+              correctionValues[name]?.updated?.trim(),
           )
         );
+      }
+      return selectedPurposes.some(
+        (p) => p.selected || p.data_elements.some((de) => de.selected),
+      );
+    }
+
+    switch (requestType) {
+      case RequestTypeEnum.GRIEVANCE:
+        return Object.values(selectedGrievances).some(Boolean);
 
       case RequestTypeEnum.NOMINATION:
-        return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(nominationData.nominee_email.trim());
+        return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(
+          nominationData.nominee_email.trim(),
+        );
 
       default:
         return false;
     }
   }, [
     requestType,
-    useGroupedRender,
-    selectedGroups,
-    purposesByGroupKey,
-    correctionElementsByGroupKey,
-    correctionValuesByGroupKey,
-    accessPurposes,
-    erasurePurposes,
-    selectedGrievances,
+    allGroups,
+    selectedGroup,
+    selectedPurposes,
     selectedCorrectionElements,
     correctionValues,
+    selectedGrievances,
     nominationData,
   ]);
 
@@ -1567,13 +954,11 @@ export default function Form({
 
   return (
     <>
-      {isSubmitted && batchResult && !isPopup ? (
+      {isSubmitted && submittedCase && !isPopup ? (
         <RequestSubmit
-          result={batchResult}
+          result={submittedCase}
           contact={formData?.contact}
           onCreateRequest={onCreateRequest}
-          onRetry={handleRetry}
-          retryingGroupKeys={retryingGroupKeys}
         />
       ) : (
         <div>
@@ -1777,7 +1162,7 @@ export default function Form({
                       <div style={{
                         padding: getVar('--pc-spacing-md'),
                       }}>
-                        {useGroupedRender && isGroupedRequestType(requestType) ? (
+                        {isProductScopedRequestType(requestType) ? (
                           <div
                             style={{
                               ...pcStyles.flex,
@@ -1795,22 +1180,16 @@ export default function Form({
                                 isTranslating={isTranslating}
                               />
                             )}
-                            {selectedGroups.length > 0 && (() => {
-                              const group = selectedGroups[0];
-                              const key = productGroupKey(group);
-                              const groupPurposes = purposesByGroupKey.get(key) ?? [];
+                            {selectedGroup && (() => {
+                              const key = productGroupKey(selectedGroup);
                               const isCorrection =
                                 requestType === RequestTypeEnum.CORRECTION;
                               const groupDataElements = isCorrection
-                                ? buildGroupDataElements(group)
+                                ? buildGroupDataElements(selectedGroup)
                                 : [];
-                              const groupCorrectionSelected =
-                                correctionElementsByGroupKey.get(key) ?? [];
-                              const groupCorrectionValues =
-                                correctionValuesByGroupKey.get(key) ?? {};
-                              const nominatorLabel = group.nominator
-                                ? group.nominator.name ??
-                                  group.nominator.email ??
+                              const nominatorLabel = selectedGroup.nominator
+                                ? selectedGroup.nominator.name ??
+                                  selectedGroup.nominator.email ??
                                   ''
                                 : '';
 
@@ -1828,9 +1207,9 @@ export default function Form({
                                         color="primary"
                                         className="pc-product-purpose-panel-title"
                                       >
-                                        {group.product_name}
+                                        {selectedGroup.product_name}
                                       </PCText>
-                                      {group.nominator && (
+                                      {selectedGroup.nominator && (
                                         <PCText
                                           as="span"
                                           size="xs"
@@ -1860,22 +1239,16 @@ export default function Form({
                                     {isCorrection ? (
                                       <CorrectionDataSection
                                         dataElements={groupDataElements}
-                                        selected={groupCorrectionSelected}
-                                        setSelected={(values) =>
-                                          setCorrectionElementsForGroup(key, values)
-                                        }
-                                        correctionValues={groupCorrectionValues}
-                                        setCorrectionValues={(values) =>
-                                          setCorrectionValuesForGroup(key, values)
-                                        }
+                                        selected={selectedCorrectionElements}
+                                        setSelected={setSelectedCorrectionElements}
+                                        correctionValues={correctionValues}
+                                        setCorrectionValues={setCorrectionValues}
                                         isTranslating={isTranslating}
                                       />
                                     ) : (
                                       <PurposeSelectionSection
-                                        purposes={groupPurposes}
-                                        setPurposes={(updated) =>
-                                          setPurposesForGroup(key, updated)
-                                        }
+                                        purposes={selectedPurposes}
+                                        setPurposes={setSelectedPurposes}
                                         requestType={requestType}
                                         isTranslating={isTranslating}
                                       />
@@ -1885,31 +1258,6 @@ export default function Form({
                               );
                             })()}
                           </div>
-                        ) : requestType === RequestTypeEnum.ACCESS ||
-                          requestType === RequestTypeEnum.ERASURE ? (
-                          <PurposeSelectionSection
-                            purposes={
-                              requestType === RequestTypeEnum.ACCESS
-                                ? accessPurposes
-                                : erasurePurposes
-                            }
-                            setPurposes={
-                              requestType === RequestTypeEnum.ACCESS
-                                ? setAccessPurposes
-                                : setErasurePurposes
-                            }
-                            requestType={requestType}
-                            isTranslating={isTranslating}
-                          />
-                        ) : requestType === RequestTypeEnum.CORRECTION ? (
-                          <CorrectionDataSection
-                            dataElements={uniqueDataElements}
-                            selected={selectedCorrectionElements}
-                            setSelected={setSelectedCorrectionElements}
-                            correctionValues={correctionValues}
-                            setCorrectionValues={setCorrectionValues}
-                            isTranslating={isTranslating}
-                          />
                         ) : requestType === RequestTypeEnum.GRIEVANCE ? (
                           <GrievanceDataSection
                             grievanceOptions={grievanceOptions}