fix: add condition to pick correct schemas for fixed array items in topathschemainternal util

CHANGELOG.md

@@ -17,6 +17,10 @@ should change the heading of the (upcoming) version to include a major version b
 -->
 # 5.13.3
 
+## @rjsf/utils
+
+- Updated `toPathSchemaInternal()` util to generate correct path schemas for fixed arrays by picking up individual schemas in the `items` array, fixing [#3909](https://github.com/rjsf-team/react-jsonschema-form/issues/3909)
+
 ## @rjsf/core
 
 - Replaced the deprecated `UNSAFE_componentWillReceiveProps()` method in the Form.tsx component with an improved solution utilizing the React lifecycle methods: `getSnapshotBeforeUpdate()` and `componentDidUpdate()`. Fixing [#1794](https://github.com/rjsf-team/react-jsonschema-form/issues/1794)

packages/utils/src/schema/toPathSchema.ts

@@ -73,16 +73,44 @@ function toPathSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema,
   }
 
   if (ITEMS_KEY in schema && Array.isArray(formData)) {
-    formData.forEach((element, i: number) => {
-      pathSchema[i] = toPathSchemaInternal<T, S, F>(
-        validator,
-        schema.items as S,
-        `${name}.${i}`,
-        rootSchema,
-        element,
-        _recurseList
-      );
-    });
+    const { items: schemaItems, additionalItems: schemaAdditionalItems } = schema;
+
+    if (Array.isArray(schemaItems)) {
+      formData.forEach((element, i: number) => {
+        if (schemaItems[i]) {
+          pathSchema[i] = toPathSchemaInternal<T, S, F>(
+            validator,
+            schemaItems[i] as S,
+            `${name}.${i}`,
+            rootSchema,
+            element,
+            _recurseList
+          );
+        } else if (schemaAdditionalItems) {
+          pathSchema[i] = toPathSchemaInternal<T, S, F>(
+            validator,
+            schemaAdditionalItems as S,
+            `${name}.${i}`,
+            rootSchema,
+            element,
+            _recurseList
+          );
+        } else {
+          console.warn(`Unable to generate path schema for "${name}.${i}". No schema defined for it`);
+        }
+      });
+    } else {
+      formData.forEach((element, i: number) => {
+        pathSchema[i] = toPathSchemaInternal<T, S, F>(
+          validator,
+          schemaItems as S,
+          `${name}.${i}`,
+          rootSchema,
+          element,
+          _recurseList
+        );
+      });
+    }
   } else if (PROPERTIES_KEY in schema) {
     for (const property in schema.properties) {
       const field = get(schema, [PROPERTIES_KEY, property]);

packages/utils/test/schema/toPathSchemaTest.ts

@@ -4,6 +4,17 @@ import { TestValidatorType } from './types';
 
 export default function toPathSchemaTest(testValidator: TestValidatorType) {
   describe('toPathSchema()', () => {
+    let consoleWarnSpy: jest.SpyInstance;
+
+    beforeAll(() => {
+      // spy on console.warn() and make it do nothing to avoid making noise in the test
+      consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
+    });
+
+    afterAll(() => {
+      consoleWarnSpy.mockRestore();
+    });
+
     it('should return a pathSchema for root field', () => {
       const schema: RJSFSchema = { type: 'string' };
 
@@ -702,5 +713,182 @@ export default function toPathSchemaTest(testValidator: TestValidatorType) {
         },
       });
     });
+
+    it('should handle fixed array items which are objects', () => {
+      const schema: RJSFSchema = {
+        type: 'object',
+        properties: {
+          str: { type: 'string' },
+          arr: {
+            type: 'array',
+            items: [
+              {
+                type: 'object',
+                properties: {
+                  name: { type: 'string' },
+                },
+              },
+            ],
+          },
+        },
+      };
+
+      const formData = {
+        str: 'string',
+        arr: [{ name: 'name1' }],
+      };
+
+      expect(toPathSchema(testValidator, schema, '', schema, formData)).toEqual({
+        $name: '',
+        arr: {
+          $name: 'arr',
+          '0': {
+            $name: 'arr.0',
+            name: {
+              $name: 'arr.0.name',
+            },
+          },
+        },
+        str: {
+          $name: 'str',
+        },
+      });
+    });
+
+    it('should handle fixed array items which are objects, which have additionalItems in the schema and have additional items in the form data', () => {
+      const schema: RJSFSchema = {
+        type: 'object',
+        properties: {
+          str: { type: 'string' },
+          arr: {
+            type: 'array',
+            items: [
+              {
+                type: 'object',
+                properties: {
+                  name: { type: 'string' },
+                },
+              },
+            ],
+            additionalItems: {
+              type: 'string',
+            },
+          },
+        },
+      };
+
+      const formData = {
+        str: 'string',
+        arr: [{ name: 'name1' }, 'name2'],
+      };
+
+      expect(toPathSchema(testValidator, schema, '', schema, formData)).toEqual({
+        $name: '',
+        arr: {
+          $name: 'arr',
+          '0': {
+            $name: 'arr.0',
+            name: {
+              $name: 'arr.0.name',
+            },
+          },
+          '1': {
+            $name: 'arr.1',
+          },
+        },
+        str: {
+          $name: 'str',
+        },
+      });
+    });
+
+    it("should handle fixed array items which are objects, which have additionalItems in the schema but don't have additional items in the form data", () => {
+      const schema: RJSFSchema = {
+        type: 'object',
+        properties: {
+          str: { type: 'string' },
+          arr: {
+            type: 'array',
+            items: [
+              {
+                type: 'object',
+                properties: {
+                  name: { type: 'string' },
+                },
+              },
+            ],
+            additionalItems: {
+              type: 'string',
+            },
+          },
+        },
+      };
+
+      const formData = {
+        str: 'string',
+        arr: [{ name: 'name1' }],
+      };
+
+      expect(toPathSchema(testValidator, schema, '', schema, formData)).toEqual({
+        $name: '',
+        arr: {
+          $name: 'arr',
+          '0': {
+            $name: 'arr.0',
+            name: {
+              $name: 'arr.0.name',
+            },
+          },
+        },
+        str: {
+          $name: 'str',
+        },
+      });
+    });
+
+    it('should handle fixed array items which are objects, which have additionalItems as false in the schema but have additional items in the form data', () => {
+      const schema: RJSFSchema = {
+        type: 'object',
+        properties: {
+          str: { type: 'string' },
+          arr: {
+            type: 'array',
+            items: [
+              {
+                type: 'object',
+                properties: {
+                  name: { type: 'string' },
+                },
+              },
+            ],
+            additionalItems: false,
+          },
+        },
+      };
+
+      const formData = {
+        str: 'string',
+        arr: [{ name: 'name1' }, 'name2'],
+      };
+
+      expect(toPathSchema(testValidator, schema, '', schema, formData)).toEqual({
+        $name: '',
+        arr: {
+          $name: 'arr',
+          '0': {
+            $name: 'arr.0',
+            name: {
+              $name: 'arr.0.name',
+            },
+          },
+        },
+        str: {
+          $name: 'str',
+        },
+      });
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        'Unable to generate path schema for ".arr.1". No schema defined for it'
+      );
+    });
   });
 }