From c6fdb92dc00842403b05c2d57416707eee13c5d7 Mon Sep 17 00:00:00 2001
From: Abdallah Al-Soqatri <abdallah.al-soqatri@aspentech.com>
Date: Tue, 28 May 2024 13:03:29 +0200
Subject: [PATCH 1/2] Fixed performance issue #4203

---
 CHANGELOG.md                                  | 10 +++++++
 packages/validator-ajv6/src/validator.ts      | 24 ++++++++++++++---
 packages/validator-ajv8/src/validator.ts      | 27 +++++++++++++------
 .../validator-ajv8/test/validator.test.ts     |  9 +++----
 4 files changed, 52 insertions(+), 18 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index eadf9bea7f..3b4a8a89eb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,6 +16,16 @@ should change the heading of the (upcoming) version to include a major version b
 
 -->
 
+# 5.18.5
+
+## @rjsf/validator-ajv6
+
+- Improved performance issues with large schema dependencies and oneOf conditions [#4203](https://github.com/rjsf-team/react-jsonschema-form/issues/4203).
+
+## @rjsf/validator-ajv8
+
+- Improved performance issues with large schema dependencies and oneOf conditions [#4203](https://github.com/rjsf-team/react-jsonschema-form/issues/4203).
+
 # 5.18.4
 
 ## Dev / docs / playground
diff --git a/packages/validator-ajv6/src/validator.ts b/packages/validator-ajv6/src/validator.ts
index 02249bd8d2..ee65186c93 100644
--- a/packages/validator-ajv6/src/validator.ts
+++ b/packages/validator-ajv6/src/validator.ts
@@ -2,6 +2,7 @@ import { Ajv, ErrorObject } from 'ajv';
 import {
   createErrorHandler,
   CustomValidator,
+  deepEquals,
   ErrorSchema,
   ErrorTransformer,
   FormContextType,
@@ -158,6 +159,16 @@ export default class AJV6Validator<T = any, S extends StrictRJSFSchema = RJSFSch
     return validationDataMerge<T>({ errors, errorSchema }, userErrorSchema);
   }
 
+  /**
+   * This function is called when the root schema changes. It removes the old root schema from the ajv instance and adds the new one.
+   * @param rootSchema - The root schema used to provide $ref resolutions
+   */
+  handleRootSchemaChange(rootSchema: RJSFSchema): void {
+    const rootSchemaId = ROOT_SCHEMA_PREFIX;
+    this.ajv.removeSchema(rootSchemaId);
+    this.ajv.addSchema(rootSchema, rootSchemaId);
+  }
+
   /** Validates data against a schema, returning true if the data is valid, or
    * false otherwise. If the schema is invalid, then this function will return
    * false.
@@ -169,16 +180,21 @@ export default class AJV6Validator<T = any, S extends StrictRJSFSchema = RJSFSch
   isValid(schema: RJSFSchema, formData: T | undefined, rootSchema: RJSFSchema) {
     try {
       // add the rootSchema ROOT_SCHEMA_PREFIX as id.
+      // if schema validator instance doesn't exist, add it.
+      // else 'handleRootSchemaChange' should be called if the root schema changes so we don't have to remove and recompile the schema every run.
+      if (this.ajv.getSchema(ROOT_SCHEMA_PREFIX) === undefined) {
+        // TODO restore the commented out `if` above when the TODO in the `finally` is completed
+        this.ajv.addSchema(rootSchema, ROOT_SCHEMA_PREFIX);
+      } else if (!deepEquals(rootSchema, this.ajv.getSchema(ROOT_SCHEMA_PREFIX)?.schema)) {
+        this.handleRootSchemaChange(rootSchema);
+      }
       // then rewrite the schema ref's to point to the rootSchema
       // this accounts for the case where schema have references to models
       // that lives in the rootSchema but not in the schema in question.
-      const result = this.ajv.addSchema(rootSchema, ROOT_SCHEMA_PREFIX).validate(withIdRefPrefix(schema), formData);
+      const result = this.ajv.validate(withIdRefPrefix(schema), formData);
       return result as boolean;
     } catch (e) {
       return false;
-    } finally {
-      // make sure we remove the rootSchema from the global ajv instance
-      this.ajv.removeSchema(ROOT_SCHEMA_PREFIX);
     }
   }
 }
diff --git a/packages/validator-ajv8/src/validator.ts b/packages/validator-ajv8/src/validator.ts
index d24bda68a4..d2737de6ca 100644
--- a/packages/validator-ajv8/src/validator.ts
+++ b/packages/validator-ajv8/src/validator.ts
@@ -1,6 +1,7 @@
 import Ajv, { ErrorObject, ValidateFunction } from 'ajv';
 import {
   CustomValidator,
+  deepEquals,
   ErrorSchema,
   ErrorTransformer,
   FormContextType,
@@ -119,6 +120,16 @@ export default class AJV8Validator<T = any, S extends StrictRJSFSchema = RJSFSch
     return processRawValidationErrors(this, rawErrors, formData, schema, customValidate, transformErrors, uiSchema);
   }
 
+  /**
+   * This function is called when the root schema changes. It removes the old root schema from the ajv instance and adds the new one.
+   * @param rootSchema - The root schema used to provide $ref resolutions
+   */
+  handleRootSchemaChange(rootSchema: S): void {
+    const rootSchemaId = rootSchema[ID_KEY] ?? ROOT_SCHEMA_PREFIX;
+    this.ajv.removeSchema(rootSchemaId);
+    this.ajv.addSchema(rootSchema, rootSchemaId);
+  }
+
   /** Validates data against a schema, returning true if the data is valid, or
    * false otherwise. If the schema is invalid, then this function will return
    * false.
@@ -131,13 +142,17 @@ export default class AJV8Validator<T = any, S extends StrictRJSFSchema = RJSFSch
     const rootSchemaId = rootSchema[ID_KEY] ?? ROOT_SCHEMA_PREFIX;
     try {
       // add the rootSchema ROOT_SCHEMA_PREFIX as id.
+      // if schema validator instance doesn't exist, add it.
+      // else 'handleRootSchemaChange' should be called if the root schema changes so we don't have to remove and recompile the schema every run.
+      if (this.ajv.getSchema(rootSchemaId) === undefined) {
+        // TODO restore the commented out `if` above when the TODO in the `finally` is completed
+        this.ajv.addSchema(rootSchema, rootSchemaId);
+      } else if (!deepEquals(rootSchema, this.ajv.getSchema(rootSchemaId)?.schema)) {
+        this.handleRootSchemaChange(rootSchema);
+      }
       // then rewrite the schema ref's to point to the rootSchema
       // this accounts for the case where schema have references to models
       // that lives in the rootSchema but not in the schema in question.
-      // if (this.ajv.getSchema(rootSchemaId) === undefined) {
-      // TODO restore the commented out `if` above when the TODO in the `finally` is completed
-      this.ajv.addSchema(rootSchema, rootSchemaId);
-      // }
       const schemaWithIdRefPrefix = withIdRefPrefix<S>(schema) as S;
       const schemaId = schemaWithIdRefPrefix[ID_KEY] ?? hashForSchema(schemaWithIdRefPrefix);
       let compiledValidator: ValidateFunction | undefined;
@@ -155,10 +170,6 @@ export default class AJV8Validator<T = any, S extends StrictRJSFSchema = RJSFSch
     } catch (e) {
       console.warn('Error encountered compiling schema:', e);
       return false;
-    } finally {
-      // TODO: A function should be called if the root schema changes so we don't have to remove and recompile the schema every run.
-      // make sure we remove the rootSchema from the global ajv instance
-      this.ajv.removeSchema(rootSchemaId);
     }
   }
 }
diff --git a/packages/validator-ajv8/test/validator.test.ts b/packages/validator-ajv8/test/validator.test.ts
index 470a4e27a9..cab924497b 100644
--- a/packages/validator-ajv8/test/validator.test.ts
+++ b/packages/validator-ajv8/test/validator.test.ts
@@ -99,10 +99,9 @@ describe('AJV8Validator', () => {
         validator.isValid(schema, formData, rootSchema);
 
         // Root schema is added twice
-        expect(addSchemaSpy).toHaveBeenCalledTimes(3);
+        expect(addSchemaSpy).toHaveBeenCalledTimes(2);
         expect(addSchemaSpy).toHaveBeenNthCalledWith(1, expect.objectContaining(rootSchema), rootSchema.$id);
         expect(addSchemaSpy).toHaveBeenNthCalledWith(2, expect.objectContaining(schema), schema.$id);
-        expect(addSchemaSpy).toHaveBeenLastCalledWith(expect.objectContaining(rootSchema), rootSchema.$id);
       });
       it('should fallback to using compile', () => {
         const schema: RJSFSchema = {
@@ -594,10 +593,9 @@ describe('AJV8Validator', () => {
         validator.isValid(schema, formData, rootSchema);
 
         // Root schema is added twice
-        expect(addSchemaSpy).toHaveBeenCalledTimes(3);
+        expect(addSchemaSpy).toHaveBeenCalledTimes(2);
         expect(addSchemaSpy).toHaveBeenNthCalledWith(1, expect.objectContaining(rootSchema), rootSchema.$id);
         expect(addSchemaSpy).toHaveBeenNthCalledWith(2, expect.objectContaining(schema), schema.$id);
-        expect(addSchemaSpy).toHaveBeenLastCalledWith(expect.objectContaining(rootSchema), rootSchema.$id);
       });
     });
     describe('validator.toErrorList()', () => {
@@ -1050,10 +1048,9 @@ describe('AJV8Validator', () => {
         validator.isValid(schema, formData, rootSchema);
 
         // Root schema is added twice
-        expect(addSchemaSpy).toHaveBeenCalledTimes(3);
+        expect(addSchemaSpy).toHaveBeenCalledTimes(2);
         expect(addSchemaSpy).toHaveBeenNthCalledWith(1, expect.objectContaining(rootSchema), rootSchema.$id);
         expect(addSchemaSpy).toHaveBeenNthCalledWith(2, expect.objectContaining(schema), schema.$id);
-        expect(addSchemaSpy).toHaveBeenLastCalledWith(expect.objectContaining(rootSchema), rootSchema.$id);
       });
     });
     describe('validator.toErrorList()', () => {

From 042e93c2231a9d3e3d8f6da5d397df8bf580d4c6 Mon Sep 17 00:00:00 2001
From: Abdallah Al-Soqatri <abdallah.al-soqatri@aspentech.com>
Date: Fri, 21 Jun 2024 10:44:13 +0200
Subject: [PATCH 2/2] code improvement based on feedback

---
 packages/validator-ajv6/src/validator.ts | 26 ++++++++++++------------
 packages/validator-ajv8/src/validator.ts | 26 +++++++++++-------------
 2 files changed, 25 insertions(+), 27 deletions(-)

diff --git a/packages/validator-ajv6/src/validator.ts b/packages/validator-ajv6/src/validator.ts
index ee65186c93..b8369c42f4 100644
--- a/packages/validator-ajv6/src/validator.ts
+++ b/packages/validator-ajv6/src/validator.ts
@@ -160,13 +160,21 @@ export default class AJV6Validator<T = any, S extends StrictRJSFSchema = RJSFSch
   }
 
   /**
-   * This function is called when the root schema changes. It removes the old root schema from the ajv instance and adds the new one.
+   * This function checks if a schema needs to be added and if the root schemas don't match it removes the old root schema from the ajv instance and adds the new one.
    * @param rootSchema - The root schema used to provide $ref resolutions
    */
-  handleRootSchemaChange(rootSchema: RJSFSchema): void {
+  handleSchemaUpdate(rootSchema: RJSFSchema): void {
     const rootSchemaId = ROOT_SCHEMA_PREFIX;
-    this.ajv.removeSchema(rootSchemaId);
-    this.ajv.addSchema(rootSchema, rootSchemaId);
+    // add the rootSchema ROOT_SCHEMA_PREFIX as id.
+    // if schema validator instance doesn't exist, add it.
+    // else 'handleRootSchemaChange' should be called if the root schema changes so we don't have to remove and recompile the schema every run.
+    if (this.ajv.getSchema(ROOT_SCHEMA_PREFIX) === undefined) {
+      // TODO restore the commented out `if` above when the TODO in the `finally` is completed
+      this.ajv.addSchema(rootSchema, ROOT_SCHEMA_PREFIX);
+    } else if (!deepEquals(rootSchema, this.ajv.getSchema(ROOT_SCHEMA_PREFIX)?.schema)) {
+      this.ajv.removeSchema(rootSchemaId);
+      this.ajv.addSchema(rootSchema, rootSchemaId);
+    }
   }
 
   /** Validates data against a schema, returning true if the data is valid, or
@@ -179,15 +187,7 @@ export default class AJV6Validator<T = any, S extends StrictRJSFSchema = RJSFSch
    */
   isValid(schema: RJSFSchema, formData: T | undefined, rootSchema: RJSFSchema) {
     try {
-      // add the rootSchema ROOT_SCHEMA_PREFIX as id.
-      // if schema validator instance doesn't exist, add it.
-      // else 'handleRootSchemaChange' should be called if the root schema changes so we don't have to remove and recompile the schema every run.
-      if (this.ajv.getSchema(ROOT_SCHEMA_PREFIX) === undefined) {
-        // TODO restore the commented out `if` above when the TODO in the `finally` is completed
-        this.ajv.addSchema(rootSchema, ROOT_SCHEMA_PREFIX);
-      } else if (!deepEquals(rootSchema, this.ajv.getSchema(ROOT_SCHEMA_PREFIX)?.schema)) {
-        this.handleRootSchemaChange(rootSchema);
-      }
+      this.handleSchemaUpdate(rootSchema);
       // then rewrite the schema ref's to point to the rootSchema
       // this accounts for the case where schema have references to models
       // that lives in the rootSchema but not in the schema in question.
diff --git a/packages/validator-ajv8/src/validator.ts b/packages/validator-ajv8/src/validator.ts
index d2737de6ca..5d4ff6f420 100644
--- a/packages/validator-ajv8/src/validator.ts
+++ b/packages/validator-ajv8/src/validator.ts
@@ -121,13 +121,20 @@ export default class AJV8Validator<T = any, S extends StrictRJSFSchema = RJSFSch
   }
 
   /**
-   * This function is called when the root schema changes. It removes the old root schema from the ajv instance and adds the new one.
+   * This function checks if a schema needs to be added and if the root schemas don't match it removes the old root schema from the ajv instance and adds the new one.
    * @param rootSchema - The root schema used to provide $ref resolutions
    */
-  handleRootSchemaChange(rootSchema: S): void {
+  handleSchemaUpdate(rootSchema: S): void {
     const rootSchemaId = rootSchema[ID_KEY] ?? ROOT_SCHEMA_PREFIX;
-    this.ajv.removeSchema(rootSchemaId);
-    this.ajv.addSchema(rootSchema, rootSchemaId);
+    // add the rootSchema ROOT_SCHEMA_PREFIX as id.
+    // if schema validator instance doesn't exist, add it.
+    // else if the root schemas don't match, we should remove and add the root schema so we don't have to remove and recompile the schema every run.
+    if (this.ajv.getSchema(rootSchemaId) === undefined) {
+      this.ajv.addSchema(rootSchema, rootSchemaId);
+    } else if (!deepEquals(rootSchema, this.ajv.getSchema(rootSchemaId)?.schema)) {
+      this.ajv.removeSchema(rootSchemaId);
+      this.ajv.addSchema(rootSchema, rootSchemaId);
+    }
   }
 
   /** Validates data against a schema, returning true if the data is valid, or
@@ -139,17 +146,8 @@ export default class AJV8Validator<T = any, S extends StrictRJSFSchema = RJSFSch
    * @param rootSchema - The root schema used to provide $ref resolutions
    */
   isValid(schema: S, formData: T | undefined, rootSchema: S) {
-    const rootSchemaId = rootSchema[ID_KEY] ?? ROOT_SCHEMA_PREFIX;
     try {
-      // add the rootSchema ROOT_SCHEMA_PREFIX as id.
-      // if schema validator instance doesn't exist, add it.
-      // else 'handleRootSchemaChange' should be called if the root schema changes so we don't have to remove and recompile the schema every run.
-      if (this.ajv.getSchema(rootSchemaId) === undefined) {
-        // TODO restore the commented out `if` above when the TODO in the `finally` is completed
-        this.ajv.addSchema(rootSchema, rootSchemaId);
-      } else if (!deepEquals(rootSchema, this.ajv.getSchema(rootSchemaId)?.schema)) {
-        this.handleRootSchemaChange(rootSchema);
-      }
+      this.handleSchemaUpdate(rootSchema);
       // then rewrite the schema ref's to point to the rootSchema
       // this accounts for the case where schema have references to models
       // that lives in the rootSchema but not in the schema in question.