fix(GAT-9356): Form hydration causing error on save as draft (#1595)

Author: calmacx

src/consts/createDataset.ts

@@ -2,6 +2,9 @@ const INITIAL_FORM_SECTION = "Welcome and form builder";
 const SUBMISSON_FORM_SECTION = "Make active";
 const STRUCTURAL_METADATA_FORM_SECTION = "structuralMetadata";
 const DATASET_TYPE = "Dataset type";
+const DATASET_TYPE_ARRAY = "Dataset Type Array";
+const DATASET_SUBTYPES = "Dataset subtypes";
+const PROVENANCE_ORIGIN_DATASET_TYPE_PATH = "provenance.origin.datasetType";
 const DATA_CUSTODIAN_ID = "identifier";
 const DATA_CUSTODIAN_NAME = "Name of Data Custodian";
 const PATIENT_PATHWAY_DESCRIPTION = "Patient pathway description";
@@ -18,6 +21,9 @@ export {
     SUBMISSON_FORM_SECTION,
     STRUCTURAL_METADATA_FORM_SECTION,
     DATASET_TYPE,
+    DATASET_TYPE_ARRAY,
+    DATASET_SUBTYPES,
+    PROVENANCE_ORIGIN_DATASET_TYPE_PATH,
     DATA_CUSTODIAN_ID,
     DATA_CUSTODIAN_NAME,
     DATA_CUSTODIAN_FIELDS,

src/utils/formHydration.test.tsx

@@ -1,9 +1,14 @@
 import { buildYup } from "schema-to-yup";
-import { FormHydrationValidation } from "@/interfaces/FormHydration";
+import { Metadata } from "@/interfaces/Dataset";
+import {
+    FormHydration,
+    FormHydrationValidation,
+} from "@/interfaces/FormHydration";
 import {
     formGenerateLegendItems,
     formGetFieldsCompletedCount,
     generateValidationRules,
+    mapFormFieldsForSubmission,
 } from "./formHydration";
 
 const buildYupSchema = (validationFields: FormHydrationValidation[]) =>
@@ -118,9 +123,9 @@ describe("generateValidationRules", () => {
     it("rejects a non-URL value in an optional url-format array field", () => {
         const schema = buildYupSchema(toolsValidation);
 
-        expect(() =>
-            schema.validateSync({ Tools: ["das"] })
-        ).toThrow(/must be a valid URL/);
+        expect(() => schema.validateSync({ Tools: ["das"] })).toThrow(
+            /must be a valid URL/
+        );
     });
 
     it("accepts a valid URL in an optional url-format array field", () => {
@@ -154,9 +159,66 @@ describe("generateValidationRules", () => {
         const schema = buildYupSchema(requiredEnumValidation);
 
         expect(() => schema.validateSync({ Category: [] })).toThrow();
-        expect(() =>
-            schema.validateSync({ Category: ["A"] })
-        ).not.toThrow();
+        expect(() => schema.validateSync({ Category: ["A"] })).not.toThrow();
+    });
+});
+
+describe("mapFormFieldsForSubmission", () => {
+    // A minimal schema for a single field that lives outside the provenance
+    // section, so a "partial draft" produces formattedFormData with no
+    // provenance branch at all - the exact condition that used to throw.
+    const schema = [
+        {
+            title: "Title",
+            is_array_form: false,
+            location: "summary.title",
+            field: {
+                component: "TextField",
+                name: "Title",
+                required: true,
+                hidden: false,
+            },
+        },
+    ] as unknown as FormHydration[];
+
+    const submit = (formData: Record<string, unknown>) =>
+        mapFormFieldsForSubmission(formData as unknown as Metadata, schema) as {
+            provenance?: { origin?: { datasetType?: unknown } };
+        };
+
+    it("does not throw when the provenance section is empty (partial draft)", () => {
+        expect(() => submit({ Title: "A partial draft" })).not.toThrow();
+    });
+
+    it("defaults datasetType to an empty array when Dataset Type Array is absent", () => {
+        const result = submit({ Title: "A partial draft" });
+
+        expect(result.provenance?.origin?.datasetType).toEqual([]);
+    });
+
+    it("maps Dataset Type Array into provenance.origin.datasetType when provenance is otherwise empty", () => {
+        const result = submit({
+            "Dataset Type Array": [
+                {
+                    "Dataset type": "Health and disease",
+                    "Dataset subtypes": ["Cancer"],
+                },
+            ],
+        });
+
+        expect(result.provenance?.origin?.datasetType).toEqual([
+            { name: "Health and disease", subTypes: ["Cancer"] },
+        ]);
+    });
+
+    it("defaults subTypes to an empty array when Dataset subtypes is missing", () => {
+        const result = submit({
+            "Dataset Type Array": [{ "Dataset type": "Health and disease" }],
+        });
+
+        expect(result.provenance?.origin?.datasetType).toEqual([
+            { name: "Health and disease", subTypes: [] },
+        ]);
     });
 });
 

src/utils/formHydration.tsx

@@ -19,7 +19,11 @@ import { LegendItem, LegendStatus } from "@/interfaces/FormLegend";
 import InputWrapper from "@/components/InputWrapper";
 import { inputComponents } from "@/config/forms";
 import {
+    DATASET_SUBTYPES,
+    DATASET_TYPE,
+    DATASET_TYPE_ARRAY,
     INITIAL_FORM_SECTION,
+    PROVENANCE_ORIGIN_DATASET_TYPE_PATH,
     SUBMISSON_FORM_SECTION,
 } from "@/consts/createDataset";
 import { getLastSplitPart } from "./string";
@@ -462,12 +466,14 @@ const mapFormFieldsForSubmission = (
         set(formattedFormData, key, value);
     });
 
-    formattedFormData.provenance.origin.datasetType = formData[
-        "Dataset Type Array"
-    ].map(item => ({
-        name: item["Dataset type"],
-        subTypes: item["Dataset subtypes"] ?? [],
-    }));
+    set(
+        formattedFormData,
+        PROVENANCE_ORIGIN_DATASET_TYPE_PATH,
+        (formData[DATASET_TYPE_ARRAY] ?? []).map(item => ({
+            name: item[DATASET_TYPE],
+            subTypes: item[DATASET_SUBTYPES] ?? [],
+        }))
+    );
     const cleanUndefinedObjects = (
         obj: Record<string, unknown>
     ): Record<string, unknown> | undefined => {