fix: Fixed 3778 By Resolving all refs in oneOf/AnyOf options (rjsf-team#3786)

* fix: Fixed 3778 By Resolving all refs in oneOf/AnyOf options * remove console log * add test for sanitizeDataForNewSchema ref resolving * Update chanelog.md

Author: cwendtxealth

CHANGELOG.md

@@ -15,6 +15,14 @@ it according to semantic versioning. For example, if your PR adds a breaking cha
 should change the heading of the (upcoming) version to include a major version bump.
 
 -->
+# 5.11.1
+
+## @rjsf/utils
+
+- Created new `resolveAllReferences()` function to resolve all references within a schema's properties and array items.
+- Updated `getClosestMatchingOption()` to use `resolveAllReferences()` for all oneOf/anyOf schemas
+- Updated `resolveAnyOrOneOfSchemas()` to use `resolveAllReferences()` for all oneOf/anyOf schemas
+
 # 5.11.0
 
 ## @rjsf/core

packages/utils/src/schema/getClosestMatchingOption.ts

@@ -6,7 +6,7 @@ import reduce from 'lodash/reduce';
 import times from 'lodash/times';
 
 import getFirstMatchingOption from './getFirstMatchingOption';
-import retrieveSchema from './retrieveSchema';
+import retrieveSchema, { resolveAllReferences } from './retrieveSchema';
 import { ONE_OF_KEY, REF_KEY, JUNK_OPTION_ID, ANY_OF_KEY } from '../constants';
 import guessType from '../guessType';
 import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
@@ -145,10 +145,7 @@ export default function getClosestMatchingOption<
 ): number {
  // First resolve any refs in the options
  const resolvedOptions = options.map((option) => {
- if (has(option, REF_KEY)) {
- return retrieveSchema<T, S, F>(validator, option, rootSchema, formData);
- }
- return option;
+ return resolveAllReferences(option, rootSchema);
  });
  // Reduce the array of options down to a list of the indexes that are considered matching options
  const allValidIndexes = resolvedOptions.reduce((validList: number[], option, index: number) => {

packages/utils/src/schema/retrieveSchema.ts

@@ -1,6 +1,7 @@
 import get from 'lodash/get';
 import set from 'lodash/set';
 import times from 'lodash/times';
+import forEach from 'lodash/forEach';
 import mergeAllOf, { Options } from 'json-schema-merge-allof';
 
 import {
@@ -12,6 +13,8 @@ import {
  IF_KEY,
  ONE_OF_KEY,
  REF_KEY,
+ PROPERTIES_KEY,
+ ITEMS_KEY,
 } from '../constants';
 import findSchemaDefinition, { splitKeyElementFromObject } from '../findSchemaDefinition';
 import getDiscriminatorFieldFromSchema from '../getDiscriminatorFieldFromSchema';
@@ -192,6 +195,39 @@ export function resolveReference<T = any, S extends StrictRJSFSchema = RJSFSchem
  );
 }
 
+/** Resolves all references within a schema's properties and array items.
+ *
+ * @param schema - The schema for which resolving all references is desired
+ * @param rootSchema - The root schema that will be forwarded to all the APIs
+ * @returns - given schema will all references resolved
+ */
+export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(schema: S, rootSchema: S): S {
+ let resolvedSchema: S = schema;
+ // resolve top level ref
+ if (REF_KEY in resolvedSchema) {
+ const { $ref, ...localSchema } = resolvedSchema;
+ // Retrieve the referenced schema definition.
+ const refSchema = findSchemaDefinition<S>($ref, rootSchema);
+ resolvedSchema = { ...refSchema, ...localSchema };
+ }
+
+ if (PROPERTIES_KEY in resolvedSchema) {
+ forEach(resolvedSchema[PROPERTIES_KEY], (value, key) => {
+ resolvedSchema[PROPERTIES_KEY]![key] = resolveAllReferences(value as S, rootSchema);
+ });
+ }
+
+ if (
+ ITEMS_KEY in resolvedSchema &&
+ !Array.isArray(resolvedSchema.items) &&
+ typeof resolvedSchema.items !== 'boolean'
+ ) {
+ resolvedSchema.items = resolveAllReferences(resolvedSchema.items as S, rootSchema);
+ }
+
+ return resolvedSchema;
+}
+
 /** Creates new 'properties' items for each key in the `formData`
  *
  * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
@@ -333,11 +369,7 @@ export function resolveAnyOrOneOfSchemas<
  const formData = rawFormData === undefined && expandAllBranches ? ({} as T) : rawFormData;
  const discriminator = getDiscriminatorFieldFromSchema<S>(schema);
  anyOrOneOf = anyOrOneOf.map((s) => {
- if (REF_KEY in s) {
- // For this ref situation, don't expand all branches and just pick the first/only schema result
- return resolveReference<T, S, F>(validator, s, rootSchema, false, formData)[0];
- }
- return s;
+ return resolveAllReferences(s, rootSchema);
  });
  // Call this to trigger the set of isValid() calls that the schema parser will need
  const option = getFirstMatchingOption<T, S, F>(validator, formData, anyOrOneOf, rootSchema, discriminator);

packages/utils/test/schema/retrieveSchemaTest.ts

@@ -1307,6 +1307,64 @@ export default function retrieveSchemaTest(testValidator: TestValidatorType) {
  },
  ]);
  });
+ it('resolves oneOf with multiple $refs', () => {
+ const schema: RJSFSchema = {
+ oneOf: [
+ {
+ type: 'object',
+ properties: {
+ field: {
+ $ref: '#/definitions/aObject',
+ },
+ },
+ },
+ {
+ type: 'array',
+ items: {
+ $ref: '#/definitions/bObject',
+ },
+ },
+ ],
+ };
+ const rootSchema: RJSFSchema = {
+ definitions: {
+ aObject: {
+ properties: {
+ a: { enum: ['typeA'] },
+ b: { type: 'number' },
+ },
+ },
+ bObject: {
+ properties: {
+ a: { enum: ['typeB'] },
+ c: { type: 'boolean' },
+ },
+ },
+ },
+ };
+ expect(resolveAnyOrOneOfSchemas(testValidator, schema, rootSchema, true)).toEqual([
+ {
+ type: 'object',
+ properties: {
+ field: {
+ properties: {
+ a: { enum: ['typeA'] },
+ b: { type: 'number' },
+ },
+ },
+ },
+ },
+ {
+ type: 'array',
+ items: {
+ properties: {
+ a: { enum: ['typeB'] },
+ c: { type: 'boolean' },
+ },
+ },
+ },
+ ]);
+ });
  });
  describe('resolveCondition()', () => {
  it('returns both conditions with expandAll', () => {

packages/utils/test/schema/sanitizeDataForNewSchemaTest.ts

@@ -258,6 +258,37 @@ export default function sanitizeDataForNewSchemaTest(testValidator: TestValidato
  })
  ).toEqual({});
  });
+ it('returns empty formData after resolving schema refs', () => {
+ const rootSchema: RJSFSchema = {
+ definitions: {
+ string_def: {
+ type: 'string',
+ },
+ },
+ };
+ const oldSchema: RJSFSchema = {
+ type: 'object',
+ properties: {
+ field: {
+ $ref: '#/definitions/string_def',
+ },
+ oldField: {
+ type: 'string',
+ },
+ },
+ };
+ const newSchema: RJSFSchema = {
+ type: 'object',
+ properties: {
+ field: {
+ $ref: '#/definitions/string_def',
+ },
+ },
+ };
+ expect(sanitizeDataForNewSchema(testValidator, rootSchema, newSchema, oldSchema, { oldField: 'test' })).toEqual(
+ {}
+ );
+ });
  it('returns data when two arrays have same boolean items', () => {
  const oldSchema: RJSFSchema = {
  type: 'array',