Merge pull request #1 from datacamp-engineering/jdmunro/fix-anyof-bug

[LO-1769] Fix default option for anyOf fields

Author: jdmunro

packages/core/src/utils.js

@@ -1158,6 +1158,26 @@ export function rangeSpec(schema) {
   return spec;
 }
 
+function recursivelyRemoveRequiredFromSchema(schema) {
+  const copyOfSchema = { ...schema };
+  const copyOfProperties = { ...schema.properties };
+  const propertyKeys = Object.keys(copyOfProperties);
+
+  delete copyOfSchema.required;
+
+  for (const key of propertyKeys) {
+    copyOfProperties[key] = { ...copyOfProperties[key] };
+    delete copyOfProperties[key].required;
+    if (copyOfProperties[key].items != null) {
+      copyOfProperties[key].items = recursivelyRemoveRequiredFromSchema(
+        copyOfProperties[key].items
+      );
+    }
+  }
+
+  return { ...copyOfSchema, properties: copyOfProperties };
+}
+
 export function getMatchingOption(formData, options, rootSchema) {
   for (let i = 0; i < options.length; i++) {
     const option = options[i];
@@ -1199,9 +1219,9 @@ export function getMatchingOption(formData, options, rootSchema) {
         augmentedSchema = Object.assign({}, option, requiresAnyOf);
       }
 
-      // Remove the "required" field as it's likely that not all fields have
+      // Remove the "required" fields as it's likely that not all fields have
       // been filled in yet, which will mean that the schema is not valid
-      delete augmentedSchema.required;
+      augmentedSchema = recursivelyRemoveRequiredFromSchema(augmentedSchema);
 
       if (isValid(augmentedSchema, formData)) {
         return i;

packages/core/test/utils_test.js

@@ -27,6 +27,7 @@ import {
   mergeSchemas,
   getDisplayLabel,
   schemaRequiresTrueValue,
+  getMatchingOption,
 } from "../src/utils";
 import { createSandbox } from "./test_utils";
 
@@ -3714,4 +3715,173 @@ describe("utils", () => {
       expect(schemaRequiresTrueValue({ type: "string" })).eql(false);
     });
   });
+
+  describe("getMatchingOption", () => {
+    describe("basic example", () => {
+      const options = Object.freeze([
+        {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              enum: ["One"],
+              default: "One",
+            },
+          },
+          required: ["type"],
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              enum: ["Two"],
+              default: "Two",
+            },
+          },
+          required: ["type"],
+        },
+      ]);
+
+      it("returns undefined (default option) if nothing matches the schema", () => {
+        const data = { type: "Three" };
+
+        expect(getMatchingOption(data, options)).eql(undefined);
+      });
+
+      it("returns the expected option if it matches the schema", () => {
+        const data = { type: "Two" };
+
+        expect(getMatchingOption(data, options)).eql(1);
+      });
+    });
+
+    describe("partial form data", () => {
+      it("returns the expected option for a partial match", () => {
+        const options = Object.freeze([
+          {
+            type: "object",
+            properties: {
+              type: {
+                type: "string",
+                enum: ["One"],
+                default: "One",
+              },
+              extraType: {
+                type: "string",
+                enum: ["extra"],
+                default: "extra",
+              },
+            },
+            required: ["type", "extraType"],
+          },
+        ]);
+        const data = { type: "One" };
+
+        expect(getMatchingOption(data, options)).eql(0);
+      });
+
+      it("disregards nested required properties", () => {
+        const options = Object.freeze([
+          {
+            type: "object",
+            properties: {
+              type: {
+                type: "string",
+                enum: ["One"],
+                default: "One",
+              },
+              extraObject: {
+                type: "object",
+                properties: {
+                  extraProperty: {
+                    type: "string",
+                  },
+                },
+                required: ["extraProperty"],
+              },
+            },
+            required: ["type", "extraObject"],
+          },
+        ]);
+        const data = { type: "One", extraObject: {} };
+
+        expect(getMatchingOption(data, options)).eql(0);
+      });
+
+      it("disregards nested required properties (array)", () => {
+        const options = Object.freeze([
+          {
+            type: "object",
+            properties: {
+              type: {
+                type: "string",
+                enum: ["One"],
+                default: "One",
+              },
+              extraArray: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    extraProperty: {
+                      type: "string",
+                    },
+                  },
+                  required: ["extraProperty"],
+                },
+                required: ["items"],
+              },
+            },
+            required: ["type", "extraArray"],
+          },
+        ]);
+        const data = { type: "One", extraArray: [] };
+
+        expect(getMatchingOption(data, options)).eql(0);
+      });
+
+      it("disregards nested required properties (recursive array)", () => {
+        const options = Object.freeze([
+          {
+            type: "object",
+            properties: {
+              type: {
+                type: "string",
+                enum: ["One"],
+                default: "One",
+              },
+              extraArray: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    nestedArray: {
+                      type: "array",
+                      items: {
+                        type: "object",
+                        properties: {
+                          nestedProperty: {
+                            type: "string",
+                          },
+                        },
+                        required: ["nestedProperty"],
+                      },
+                      required: ["items"],
+                    },
+                  },
+                  required: ["nestedArray"],
+                },
+                required: ["items"],
+              },
+            },
+            required: ["type", "extraArray"],
+          },
+        ]);
+        const data = { type: "One", extraArray: [{ nestedArray: [{}] }] };
+
+        expect(getMatchingOption(data, options)).eql(0);
+      });
+    });
+  });
 });