Support for “Extended Wildcard Expansion” in attribute labels for nested array validation

[davy209]

Currently, Spatie\LaravelData supports defining custom attribute names in validation messages using the attributes key via the DataValidationMessagesAndAttributesResolver.
However, wildcarded attributes such as users.*.email are not expanded automatically into explicit attribute names like users.0.email, users.1.email, etc.
This means when using nested data collections, custom labels are not applied to individual elements — resulting in default attribute paths (users.0.email) appearing in error messages.

I would suggest to automatically expand wildcard attribute definitions based on the incoming payload before validation runs.

//The wildcard attributes
'attributes' => [
    'users.*.email' => 'User #:index email',
]

//with payload
[
    'users' => [
        ['email' => null],
        ['email' => '[email protected]'],
    ],
]

//Will expands to
[
    'users.0.email' => 'User #1 email',
    'users.1.email' => 'User #2 email',
]

[davy209]

In our project, we needed to make validation messages more readable for nested DTO collections.
We wrapped DataValidatorResolver with our own subclass — CustomDataValidatorResolver — to expand wildcard attributes dynamically based on the payload structure.
Then, in our AppServiceProvider, we replaced the core binding:

use Spatie\LaravelData\Resolvers\DataValidatorResolver;

public function register(): void
{
    $this->app->singleton(
        DataValidatorResolver::class,
        CustomDataValidatorResolver::class
    );
}

This automatically expands all * wildcards in attribute definitions before building the validator — making the validation messages consistent with Laravel’s own wildcard behavior.

[davy209]

Sample of implemetation of our custom Resolver

<?php

namespace App\Data\Resolvers;

use App\Data\Traits\HasExtendedWildcard;
use Illuminate\Contracts\Support\Arrayable;
use Illuminate\Support\Arr;
use Illuminate\Support\Facades\Validator as ValidatorFacade;
use Illuminate\Support\Str;
use Illuminate\Validation\Validator;
use Spatie\LaravelData\Contracts\BaseData;
use Spatie\LaravelData\Contracts\ValidateableData;
use Spatie\LaravelData\Resolvers\DataValidationMessagesAndAttributesResolver;
use Spatie\LaravelData\Resolvers\DataValidationRulesResolver;
use Spatie\LaravelData\Resolvers\DataValidatorResolver;
use Spatie\LaravelData\Support\Validation\DataRules;
use Spatie\LaravelData\Support\Validation\ValidationPath;

class CustomDataValidatorResolver extends DataValidatorResolver
{
    public function __construct(
        protected DataValidationRulesResolver $dataValidationRulesResolver,
        protected DataValidationMessagesAndAttributesResolver $dataValidationMessagesAndAttributesResolver
    ) {}

    /** @param class-string<ValidateableData&BaseData> $dataClass */
    public function execute(
        string $dataClass,
        Arrayable|array $payload,
    ): Validator {
        $traits = class_uses($dataClass);
        if (! in_array(HasExtendedWildcard::class, $traits)) {
            return parent::execute($dataClass, $payload);
        }

        $payload = $payload instanceof Arrayable ? $payload->toArray() : $payload;

        $rules = $this->dataValidationRulesResolver->execute(
            $dataClass,
            $payload,
            ValidationPath::create(),
            DataRules::create()
        );

        ['messages' => $messages, 'attributes' => $attributes] = $this->dataValidationMessagesAndAttributesResolver->execute(
            $dataClass,
            $payload,
            ValidationPath::create()
        );

        $validator = ValidatorFacade::make(
            $payload,
            $rules,
            $messages,
            $this->expandWildcardAttributes($attributes, $payload)
        );

        if (method_exists($dataClass, 'stopOnFirstFailure')) {
            $validator->stopOnFirstFailure(app()->call([$dataClass, 'stopOnFirstFailure']));
        }

        $dataClass::withValidator($validator);

        return $validator;
    }

    protected static function expandWildcardAttributes(array $attributes, array $data): array
    {
        $expanded = [];

        foreach ($attributes as $key => $label) {
            if (! Str::contains($key, '*')) {
                $expanded[$key] = $label;
                continue;
            }

            $segments = explode('.', $key);
            static::expandAttributeRecursive($segments, $data, $label, '', $expanded);
        }

        return $expanded;
    }

    protected static function expandAttributeRecursive(array $segments, array $data, string $label, string $prefix, array &$expanded): void
    {
        $segment = array_shift($segments);

        if ($segment === '*') {
            foreach (array_keys($data ?? []) as $i) {
                $path = trim("$prefix.$i", '.');
                static::expandAttributeRecursive($segments, Arr::get($data, (string) $i, []), $label, $path, $expanded);
            }
            return;
        }

        if (empty($segments)) {
            $expanded[trim("$prefix.$segment", '.')] = $label;
            return;
        }

        static::expandAttributeRecursive($segments, Arr::get($data, $segment, []), $label, trim("$prefix.$segment", '.'), $expanded);
    }
}