fixed exponential recursion in calculateIndexScore by removing recursive getClosestMatchingOption call for nested oneOf

Author: adamrimon

packages/utils/src/schema/getClosestMatchingOption.ts

@@ -30,11 +30,9 @@ export const JUNK_OPTION: StrictRJSFSchema = {
 /** Recursive function that calculates the score of a `formData` against the given `schema`. The computation is fairly
  * simple. Initially the total score is 0. When `schema.properties` object exists, then all the `key/value` pairs within
  * the object are processed as follows after obtaining the formValue from `formData` using the `key`:
- * - If the `value` contains a `$ref`, `calculateIndexScore()` is called recursively with the formValue and the new
- *   schema that is the result of the ref in the schema being resolved and that sub-schema's resulting score is added to
- *   the total.
- * - If the `value` contains a `oneOf` and there is a formValue, then score based on the index returned from calling
- *   `getClosestMatchingOption()` of that oneOf.
+ * - If the `value` contains a `$ref`, it is resolved and scoring continues on the resolved schema.
+ * - If the `value` contains a `oneOf`/`anyOf` and there is a formValue, the first matching option is found via
+ *   `getFirstMatchingOption()` and `calculateIndexScore()` is called recursively on that option.
  * - If the type of the `value` is 'object', `calculateIndexScore()` is called recursively with the formValue and the
  *   `value` itself as the sub-schema, and the score is added to the total.
  * - If the type of the `value` matches the guessed-type of the `formValue`, the score is incremented by 1, UNLESS the
@@ -66,36 +64,33 @@ export function calculateIndexScore<T = any, S extends StrictRJSFSchema = RJSFSc
             return score;
           }
           if (has(value, REF_KEY)) {
-            const newSchema = retrieveSchema<T, S, F>(
+            value = retrieveSchema<T, S, F>(
               validator,
               value as S,
               rootSchema,
               formValue,
               experimental_customMergeAllOf,
             );
-            return (
-              score +
-              calculateIndexScore<T, S, F>(
-                validator,
-                rootSchema,
-                newSchema,
-                formValue || {},
-                experimental_customMergeAllOf,
-              )
-            );
           }
           if ((has(value, ONE_OF_KEY) || has(value, ANY_OF_KEY)) && formValue) {
             const key = has(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
+            const options = get(value, key) as S[];
             const discriminator = getDiscriminatorFieldFromSchema<S>(value as S);
+            const matched = getFirstMatchingOption<T, S, F>(validator, formValue, options, rootSchema, discriminator);
+            const resolvedOption = retrieveSchema<T, S, F>(
+              validator,
+              options[matched] as S,
+              rootSchema,
+              formValue,
+              experimental_customMergeAllOf,
+            );
             return (
               score +
-              getClosestMatchingOption<T, S, F>(
+              calculateIndexScore<T, S, F>(
                 validator,
                 rootSchema,
+                resolvedOption,
                 formValue,
-                get(value, key) as S[],
-                -1,
-                discriminator,
                 experimental_customMergeAllOf,
               )
             );

packages/utils/test/schema/getClosestMatchingOptionTest.ts

@@ -45,11 +45,11 @@ export default function getClosestMatchingOptionTest(testValidator: TestValidato
     it('returns 0 when formData is empty object', () => {
       expect(calculateIndexScore(testValidator, oneOfSchema, firstOption, {})).toEqual(0);
     });
-    it('returns 1 for first option in oneOf schema', () => {
-      expect(calculateIndexScore(testValidator, oneOfSchema, firstOption, ONE_OF_SCHEMA_DATA)).toEqual(1);
+    it('returns 2 for first option in oneOf schema', () => {
+      expect(calculateIndexScore(testValidator, oneOfSchema, firstOption, ONE_OF_SCHEMA_DATA)).toEqual(2);
     });
-    it('returns 8 for second option in oneOf schema', () => {
-      expect(calculateIndexScore(testValidator, oneOfSchema, secondOption, ONE_OF_SCHEMA_DATA)).toEqual(9);
+    it('returns 10 for second option in oneOf schema', () => {
+      expect(calculateIndexScore(testValidator, oneOfSchema, secondOption, ONE_OF_SCHEMA_DATA)).toEqual(10);
     });
     it('returns 1 for a schema that has a type matching the formData type', () => {
       expect(calculateIndexScore(testValidator, oneOfSchema, { type: 'boolean' }, true)).toEqual(1);
@@ -74,6 +74,34 @@ export default function getClosestMatchingOptionTest(testValidator: TestValidato
         ),
       ).toEqual(0);
     });
+    it('scores nested oneOf by finding the first matching option and recursing', () => {
+      const schema: RJSFSchema = {
+        properties: {
+          choice: {
+            oneOf: [
+              { properties: { day: { type: 'string' } } },
+              { properties: { night: { type: 'string' } } },
+            ],
+          },
+        },
+      };
+      testValidator.setReturnValues({ isValid: [true] });
+      expect(calculateIndexScore(testValidator, oneOfSchema, schema, { choice: { day: 'monday' } })).toEqual(1);
+    });
+    it('scores nested anyOf by finding the first matching option and recursing', () => {
+      const schema: RJSFSchema = {
+        properties: {
+          choice: {
+            anyOf: [
+              { properties: { x: { type: 'number' } } },
+              { properties: { y: { type: 'number' } } },
+            ],
+          },
+        },
+      };
+      testValidator.setReturnValues({ isValid: [true] });
+      expect(calculateIndexScore(testValidator, oneOfSchema, schema, { choice: { x: 42 } })).toEqual(1);
+    });
   });
   describe('oneOfMatchingOption', () => {
     it('oneOfSchema, oneOfData data, no options, returns -1', () => {
@@ -161,9 +189,10 @@ export default function getClosestMatchingOptionTest(testValidator: TestValidato
         },
       };
       const formData = { ipsum: { night: 'nicht' } };
-      // Mock to return true for the last of the second one-ofs
+      // Mock: first 3 calls (JUNK for lorem, lorem itself, JUNK for ipsum) fail;
+      // 4th call (ipsum with oneOf stripped to {}) succeeds, giving a unique valid match
       testValidator.setReturnValues({
-        isValid: [false, false, false, false, false, false, false, true],
+        isValid: [false, false, false, true],
       });
       expect(getClosestMatchingOption(testValidator, schema, formData, get(schema, 'items.oneOf'))).toEqual(1);
     });
@@ -207,9 +236,10 @@ export default function getClosestMatchingOptionTest(testValidator: TestValidato
         },
       };
       const formData = { ipsum: { night: 'nicht' } };
-      // Mock to return true for the last of the second anyOfs
+      // Mock: first 3 calls (JUNK for lorem, lorem itself, JUNK for ipsum) fail;
+      // 4th call (ipsum with anyOf stripped to {}) succeeds, giving a unique valid match
       testValidator.setReturnValues({
-        isValid: [false, false, false, false, false, false, false, true],
+        isValid: [false, false, false, true],
       });
       expect(getClosestMatchingOption(testValidator, schema, formData, get(schema, 'items.anyOf'))).toEqual(1);
     });