Validation reorders items inside nested array when nullable rule precedes required rule

[finger-ease]

Laravel Version

12.16.0

PHP Version

8.4

Database Driver & Version

No response

Description

When a FormRequest validates an array of objects where each element contains both a nullable field and a required field, the validator reorders the outer array if the nullable rule is declared before the required rule.

In the example below, $request->validated() returns the items in a different order from the input: any element that includes the optional field is moved ahead of elements that omit it.

Reversing the rule order (required first, then nullable) preserves the original order.

This unexpected reordering breaks code that relies on the positional integrity of the array—for example, bulk DB inserts or any logic that matches items by index.

Expected:

The validator should leave the outer array in the same order it was received, regardless of rule declaration order.

Actual:

The outer array is reordered whenever the nullable rule precedes the required rule.

Steps To Reproduce

Controller and FormRequest are defined as follows:

class ExampleController extends Controller
{
    public function post(
        ExampleControllerPostRequest $request,
    ): JsonResponse
    {
        return response()->json($request->validated());
    }
}

class ExampleControllerPostRequest extends FormRequest
{
    public function rules(): array
    {
        return [
            'array' => ['required', 'array'],
            'array.*.optional' => ['nullable', 'string'], // nullable before required
            'array.*.required' => ['required', 'string'],
        ];
    }
}

To reproduce, send the following request:

curl -X POST --location 'http://localhost:8000/example' \
--header 'Content-Type: application/json' \
--data '{
    "array": [
        {
            "required": "required1"
        },
        {
            "optional": "optional",
            "required": "required2"
        }
    ]
}
'

Expected response:

{
    "array": {
        "0": {
            "required": "required1"
        },
        "1": {
            "optional": "optional",
            "required": "required2"
        }
    }
}

Actual response:

{
    "array": {
        "1": {
            "optional": "optional",
            "required": "required2"
        },
        "0": {
            "required": "required1"
        }
    }
}

[robert-moore96]

while i dont have a full explanation for why its happening / how to fix it i dont think your expected response is correct

from your example it shows that the data is being converted from a "regular" array (which has a defined order) into an associative array (which doesnt)

the actual expected result to preserve the order would be

{
    "array": [
        {
            "required": "required1"
        },
        {
            "optional": "optional",
            "required": "required2"
        }
    ]
}

[amirhshokri]

This issue relates to how Laravel parses validation rules.

In your example, Laravel processes the rules in the following way:

{
  "array": [
    "required",
    "array"
  ],
  "array.0.optional": [
    "nullable",
    "string"
  ],
  "array.1.optional": [
    "nullable",
    "string"
  ],
  "array.0.required": [
    "required",
    "string"
  ],
  "array.1.required": [
    "required",
    "string"
  ]
}

First, Laravel checks for optional at index 0 but doesn’t find it. Then, it looks at index 1 and finds optional there, so it adds index 1 to the output array first.

Next, it searches for required at index 0, finds it, and adds index 0 after index 1. It then finds required at index 1 as well and merges it into index 1.

As a result, the output is exactly what you're seeing:

{
    "array": {
        "1": {
            "optional": "optional",
            "required": "required2"
        },
        "0": {
            "required": "required1"
        }
    }
}

You can refer to the validated() method in the following file for more details:

https://github.com/laravel/framework/blob/12.x/src/Illuminate/Validation/Validator.php

[finger-ease]

Thank you for the detailed explanation.

I read the code of the validated() method and now I understand how this happens.

The issue occurs in the validated() method where foreach ($this->getRules() as $key => $rules) iterates through rules in the order they were processed by ValidationRuleParser.

When ValidationRuleParser expands wildcard rules like array.*.optional, it processes them based on which data exists, rather than maintaining the original array order. This causes $this->rules to have keys in an unexpected order, which then affects the final output.

The core issue: The order of rules in $this->rules should ideally match the original data structure order, regardless of validation rule declaration order.

Would this be considered a bug worth fixing, or should developers expect to handle this behavior in their applications?