Added support for bundled JSON Schemas (rjsf-team#4599)

* Added support for bundled JSON Schemas

* Fix ajv8 build

* Added test for recursive references

Author: GlassOfWhiskey

CHANGELOG.md

@@ -61,12 +61,14 @@ should change the heading of the (upcoming) version to include a major version b
 ## @rjsf/utils
 
 - Updated the `description` field in field props to be a `string | ReactElement` and added `enableMarkdownInDescription` to the `GlobalUISchemaOptions` interface
+- Support for bundled JSON Schemas [#4505](https://github.com/rjsf-team/react-jsonschema-form/issues/4505)
 
 ## Dev / docs / playground
 
 - Updated the `snapshot-tests` to disable `getTestId()` for snapshots and updated the `formTests.tsx` to add tests for rich text descriptions for generic fields and the `CheckboxWidget`
 - Updated the `uiSchema.md` to document new `enableMarkdownInDescription` prop
 - Updated the `playground` to move `daisyui` theme choice after `chakra-ui` and to stop freezing the samples to avoid an `AJV` validation issue
+- Added a playground example for bundled JSON Schemas
 
 # 6.0.0-beta.1
 

package-lock.json

@@ -0,0 +1,41 @@
+import { Sample } from './Sample';
+
+const bundledSchema: Sample = {
+  schema: {
+    $id: 'https://jsonschema.dev/schemas/examples/non-negative-integer-bundle',
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    description: 'Must be a non-negative integer',
+    $defs: {
+      'https://jsonschema.dev/schemas/mixins/integer': {
+        $schema: 'https://json-schema.org/draft/2020-12/schema',
+        $id: 'https://jsonschema.dev/schemas/mixins/integer',
+        description: 'Must be an integer',
+        type: 'integer',
+      },
+      'https://jsonschema.dev/schemas/mixins/non-negative': {
+        $schema: 'https://json-schema.org/draft/2020-12/schema',
+        $id: 'https://jsonschema.dev/schemas/mixins/non-negative',
+        description: 'Not allowed to be negative',
+        minimum: 0,
+      },
+      nonNegativeInteger: {
+        allOf: [
+          {
+            $ref: '/schemas/mixins/integer',
+          },
+          {
+            $ref: '/schemas/mixins/non-negative',
+          },
+        ],
+      },
+    },
+    properties: {
+      num: {
+        $ref: '#/$defs/nonNegativeInteger',
+      },
+    },
+  },
+  uiSchema: {},
+};
+
+export default bundledSchema;

packages/playground/src/samples/bundledSchema.ts

@@ -34,6 +34,7 @@ import customField from './customField';
 import layoutGrid from './layoutGrid';
 import { Sample } from './Sample';
 import patternProperties from './patternProperties';
+import bundledSchema from './bundledSchema';
 
 export type { Sample };
 
@@ -74,6 +75,7 @@ const _samples: Record<string, Sample> = {
   Defaults: defaults,
   'Custom Field': customField,
   'Layout Grid': layoutGrid,
+  'Bundled Schema': bundledSchema,
 };
 
 export const samples = _samples;

packages/playground/src/samples/index.ts

@@ -65,6 +65,7 @@
     "react": ">=18"
   },
   "dependencies": {
+    "fast-uri": "^3.0.6",
     "json-schema-merge-allof": "^0.8.1",
     "jsonpointer": "^5.0.1",
     "lodash": "^4.17.21",

packages/utils/package.json

@@ -25,6 +25,7 @@ export const READONLY_KEY = 'readonly';
 export const REQUIRED_KEY = 'required';
 export const SUBMIT_BTN_OPTIONS_KEY = 'submitButtonOptions';
 export const REF_KEY = '$ref';
+export const SCHEMA_KEY = '$schema';
 /** The path of the discriminator value returned by the schema endpoint.
  * The discriminator is the value in a `oneOf` that determines which option is selected.
  */
@@ -42,3 +43,7 @@ export const UI_FIELD_KEY = 'ui:field';
 export const UI_WIDGET_KEY = 'ui:widget';
 export const UI_OPTIONS_KEY = 'ui:options';
 export const UI_GLOBAL_OPTIONS_KEY = 'ui:globalOptions';
+
+/** The JSON Schema version strings
+ */
+export const JSON_SCHEMA_DRAFT_2020_12 = 'https://json-schema.org/draft/2020-12/schema';

packages/utils/src/constants.ts

@@ -1,8 +1,33 @@
 import jsonpointer from 'jsonpointer';
 import omit from 'lodash/omit';
 
-import { REF_KEY } from './constants';
+import { ID_KEY, JSON_SCHEMA_DRAFT_2020_12, REF_KEY, SCHEMA_KEY } from './constants';
 import { GenericObjectType, RJSFSchema, StrictRJSFSchema } from './types';
+import isObject from 'lodash/isObject';
+import isEmpty from 'lodash/isEmpty';
+import UriResolver from 'fast-uri';
+
+/** Looks for the `$id` pointed by `ref` in the schema definitions embedded in
+ * a JSON Schema bundle
+ *
+ * @param schema - The schema wherein `ref` should be searched
+ * @param ref - The `$id` of the reference to search for
+ * @returns - The schema matching the reference, or `undefined` if no match is found
+ */
+function findEmbeddedSchemaRecursive<S extends StrictRJSFSchema = RJSFSchema>(schema: S, ref: string): S | undefined {
+  if (ID_KEY in schema && UriResolver.equal(schema[ID_KEY] as string, ref)) {
+    return schema;
+  }
+  for (const subSchema of Object.values(schema)) {
+    if (isObject(subSchema)) {
+      const result = findEmbeddedSchemaRecursive<S>(subSchema as S, ref);
+      if (result !== undefined) {
+        return result as S;
+      }
+    }
+  }
+  return undefined;
+}
 
 /** Splits out the value at the `key` in `object` from the `object`, returning an array that contains in the first
  * location, the `object` minus the `key: value` and in the second location the `value`.
@@ -26,23 +51,40 @@ export function splitKeyElementFromObject(key: string, object: GenericObjectType
  * @param $ref - The ref string for which the schema definition is desired
  * @param [rootSchema={}] - The root schema in which to search for the definition
  * @param recurseList - List of $refs already resolved to prevent recursion
+ * @param baseURI - The base URI to be used for resolving relative references
  * @returns - The sub-schema within the `rootSchema` which matches the `$ref` if it exists
  * @throws - Error indicating that no schema for that reference could be resolved
  */
 export function findSchemaDefinitionRecursive<S extends StrictRJSFSchema = RJSFSchema>(
   $ref?: string,
   rootSchema: S = {} as S,
   recurseList: string[] = [],
+  baseURI: string | undefined = ID_KEY in rootSchema ? rootSchema[ID_KEY] : undefined,
 ): S {
   const ref = $ref || '';
-  let decodedRef;
+  let current: S | undefined = undefined;
   if (ref.startsWith('#')) {
     // Decode URI fragment representation.
-    decodedRef = decodeURIComponent(ref.substring(1));
-  } else {
-    throw new Error(`Could not find a definition for ${$ref}.`);
+    const decodedRef = decodeURIComponent(ref.substring(1));
+    if (baseURI === undefined || (ID_KEY in rootSchema && rootSchema[ID_KEY] === baseURI)) {
+      current = jsonpointer.get(rootSchema, decodedRef);
+    } else if (rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
+      current = findEmbeddedSchemaRecursive<S>(rootSchema, baseURI.replace(/\/$/, ''));
+      if (current !== undefined) {
+        current = jsonpointer.get(current, decodedRef);
+      }
+    }
+  } else if (rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
+    const resolvedRef = baseURI ? UriResolver.resolve(baseURI, ref) : ref;
+    const [refId, ...refAnchor] = resolvedRef.replace(/#\/?$/, '').split('#');
+    current = findEmbeddedSchemaRecursive<S>(rootSchema, refId.replace(/\/$/, ''));
+    if (current !== undefined) {
+      baseURI = current[ID_KEY];
+      if (!isEmpty(refAnchor)) {
+        current = jsonpointer.get(current, decodeURIComponent(refAnchor.join('#')));
+      }
+    }
   }
-  const current: S = jsonpointer.get(rootSchema, decodedRef);
   if (current === undefined) {
     throw new Error(`Could not find a definition for ${$ref}.`);
   }
@@ -58,7 +100,7 @@ export function findSchemaDefinitionRecursive<S extends StrictRJSFSchema = RJSFS
       throw new Error(`Definition for ${firstRef} contains a circular reference through ${circularPath}`);
     }
     const [remaining, theRef] = splitKeyElementFromObject(REF_KEY, current);
-    const subSchema = findSchemaDefinitionRecursive<S>(theRef, rootSchema, [...recurseList, ref]);
+    const subSchema = findSchemaDefinitionRecursive<S>(theRef, rootSchema, [...recurseList, ref], baseURI);
     if (Object.keys(remaining).length > 0) {
       return { ...remaining, ...subSchema };
     }
@@ -74,13 +116,15 @@ export function findSchemaDefinitionRecursive<S extends StrictRJSFSchema = RJSFS
  *
  * @param $ref - The ref string for which the schema definition is desired
  * @param [rootSchema={}] - The root schema in which to search for the definition
+ * @param [baseURI=rootSchema['$id']] - The base URI to be used for resolving relative references
  * @returns - The sub-schema within the `rootSchema` which matches the `$ref` if it exists
  * @throws - Error indicating that no schema for that reference could be resolved
  */
 export default function findSchemaDefinition<S extends StrictRJSFSchema = RJSFSchema>(
   $ref?: string,
   rootSchema: S = {} as S,
+  baseURI: string | undefined = ID_KEY in rootSchema ? rootSchema[ID_KEY] : undefined,
 ): S {
   const recurseList: string[] = [];
-  return findSchemaDefinitionRecursive($ref, rootSchema, recurseList);
+  return findSchemaDefinitionRecursive($ref, rootSchema, recurseList, baseURI);
 }

packages/utils/src/findSchemaDefinition.ts

@@ -13,6 +13,7 @@ import {
   ALL_OF_KEY,
   ANY_OF_KEY,
   DEPENDENCIES_KEY,
+  ID_KEY,
   IF_KEY,
   ITEMS_KEY,
   ONE_OF_KEY,
@@ -333,12 +334,14 @@ export function resolveReference<T = any, S extends StrictRJSFSchema = RJSFSchem
  * @param schema - The schema for which resolving all references is desired
  * @param rootSchema - The root schema that will be forwarded to all the APIs
  * @param recurseList - List of $refs already resolved to prevent recursion
+ * @param baseURI - The base URI to be used for resolving relative references
  * @returns - given schema will all references resolved or the original schema if no internal `$refs` were resolved
  */
 export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
   schema: S,
   rootSchema: S,
   recurseList: string[],
+  baseURI?: string,
 ): S {
   if (!isObject(schema)) {
     return schema;
@@ -353,8 +356,11 @@ export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
     }
     recurseList.push($ref!);
     // Retrieve the referenced schema definition.
-    const refSchema = findSchemaDefinition<S>($ref, rootSchema);
+    const refSchema = findSchemaDefinition<S>($ref, rootSchema, baseURI);
     resolvedSchema = { ...refSchema, ...localSchema };
+    if (ID_KEY in resolvedSchema) {
+      baseURI = resolvedSchema[ID_KEY];
+    }
   }
 
   if (PROPERTIES_KEY in resolvedSchema) {
@@ -363,7 +369,7 @@ export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
       resolvedSchema[PROPERTIES_KEY]!,
       (result, value, key: string) => {
         const childList: string[] = [...recurseList];
-        result[key] = resolveAllReferences(value as S, rootSchema, childList);
+        result[key] = resolveAllReferences(value as S, rootSchema, childList, baseURI);
         childrenLists.push(childList);
       },
       {} as RJSFSchema,
@@ -379,7 +385,7 @@ export function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(
   ) {
     resolvedSchema = {
       ...resolvedSchema,
-      items: resolveAllReferences(resolvedSchema.items as S, rootSchema, recurseList),
+      items: resolveAllReferences(resolvedSchema.items as S, rootSchema, recurseList, baseURI),
     };
   }
 
@@ -550,6 +556,9 @@ export function retrieveSchemaInternal<
           ? experimental_customMergeAllOf(resolvedSchema)
           : (mergeAllOf(resolvedSchema, {
               deep: false,
+              resolvers: {
+                $defs: mergeAllOf.options.resolvers.definitions,
+              },
             } as Options) as S);
         if (withContainsSchemas.length) {
           resolvedSchema.allOf = withContainsSchemas;