React JSON Schema Form doesn't support `minItems` property in array validation

[Swastik19Nit]

Description

When using React JSON Schema Form with JSON Schema that includes minItems property for array validation, the form doesn't properly enforce the minimum items requirement.

Current Behavior

• When a JSON Schema includes minItems property for arrays, React JSON Schema Form ignores this validation
• Arrays can be empty even when minItems is set to a value greater than 0
• No validation errors are shown to users when array length is less than minItems

Expected Behavior

• React JSON Schema Form should respect the minItems property in JSON Schema
• Forms should prevent arrays from having fewer items than specified in minItems
• Validation errors should be shown when array length is less than minItems

Example Schema

{
  "type": "object",
  "properties": {
    "items": {
      "type": "array",
      "minItems": 1,
      "items": {
        "type": "string"
      }
    }
  }
}

Additional Context

This is a common requirement in forms where certain arrays must have at least one item. The minItems property is a standard part of JSON Schema validation, and it would be beneficial if React JSON Schema Form supported this validation rule.

Possible Workarounds

Currently, we're handling this by:

1. Adding custom validation
2. Using required property (though this doesn't enforce minimum items)
3. Implementing custom array field templates

Impact

This limitation affects form validation where arrays must have a minimum number of items, which is a common requirement in many applications.

Additional Notes

This is not a bug in the traditional sense, but rather a missing feature that would improve the library's compliance with JSON Schema standards.

[nickgros]

@Swastik19Nit RJSF does support minItems. I'm not seeing the behavior you're describing, you will need to provide a reproduction link to the RJSF Playground or CodeSandbox before we can understand what you're trying to do.

I can see a minItems validation error when submitting an array of 0 items using your schema (example playground):

If you want to pre-populate array fields to match your minItems requirement, we have experimental_defaultFormStateBehavior.arrayMinItems.

If you want to hide the 'remove' button for array fields when you have minItems, you can do so with custom templates (in particular, ArrayFieldTemplate, ArrayFieldItemTemplate, and ArrayFieldItemButtonsTemplate).

[Swastik19Nit]

Thank you for the clarification and pointing me to experimental_defaultFormStateBehavior.arrayMinItems!

You're absolutely right about minItems validation working on form submission. My issue was actually about the initial rendering behavior of arrays not validation.

The Problem I Was Experiencing

I was working on an "infer schema" feature where I generate JSON schemas from documents. When users view the inferred schema form:

• What I saw: Arrays like line_items only showed "Array of line items in the invoice" with a "+" button (no nested fields visible)
• What I needed: Users should see the actual field structure (name, quantity, price, etc.) immediately without clicking "Add Item"

This created poor UX because users couldn't see what fields were available in the array.

Solution Found

After reviewing the documentation you referenced, I found that explicitly setting the experimental flag resolved the issue:

<Form 
  schema={inferredSchema}
  formData={formData}
  experimental_defaultFormStateBehavior={{
    arrayMinItems: {
      populate: 'all',
      mergeExtraDefaults: false
    }
  }}
/>

I thought actually populate: 'all' is supposed to be the default however explicitly setting it made the arrays properly pre-populate with empty items showing the nested field structure immediately.

Alternative Approach (No Longer Needed)

Before finding your solution , I was manually adding minItems: 1 to array schemas, but the experimental flag is much cleaner and the proper way to handle this.

/* Commented out as we're using arrayMinItems.populate instead
function addMinItemsToArrays(schema: any): any {
	if (!schema) return schema;
	let patched = { ...schema };
	if (patched.type === "array") {
		patched = { ...patched, minItems: 1 };
		if (patched.items) {
			patched.items = addMinItemsToArrays(patched.items);
		}
	} else if (patched.type === "object" && patched.properties) {
		patched = { ...patched, properties: { ...patched.properties } };
		for (const [key, prop] of Object.entries(patched.properties)) {
			patched.properties[key] = addMinItemsToArrays(prop);
		}
	}
	return patched;
}
*/

Thanks for pointing me in the right direction! The arrayMinItems feature does exactly what I needed.

[nickgros]

@Swastik19Nit Glad this feature solves your problem! I am going to close this issue. If you have any other questions, feel free to create a new issue.