How to create validation Rule Object, that is dependent on other field(s)

[aedart]

I recently struggled with a problem where I needed to create a custom validation rule, that was dependent on another field's value, for a nested data structure. Unfortunately, the documentation is not very clear how developers can create custom validation rule objects that are dependent on other fields, if at all possible?

The following illustrates the desired "semantic" I was trying to achieve:

use Illuminate\Support\Facades\Validator;

Validator::make([], [
    'records' => 'array|filled',
    'records.*.field_a' => 'required|string',
    'records.*.field_b' => [
        'required',
        new MyCustomRule('records.*.field_a') // Custom rule, dependent on "records.[index].field_a" value
    ]
]);

I have searched various forums, issues, laracast, ...etc, without any success. I ended up having to use the addDependentExtensions() method to add a custom rule. While it worked in my case, I do wonder how the "correct" way of creating dependent rule objects is?

Does anyone have a good example of how the above shown example can be achieved?

[henzeb]

In the docs I read someting about the DataAwareRule interface. See
https://laravel.com/docs/9.x/validation#using-rule-objects

[aedart]

Hi @henzeb
Yes, that is true. However, the documentation does not mention anything about how you obtain the correct index of current nested row / data-set that is being processed by the validation rule. It grants you all submitted data, as far as I can see when reviewing the code - or did I miss something?

[benounnas]

any updates? i faced the same issue unfortunately 😞

[aedart]

Sadly, not yet... still no clue how to do this correctly :(

[israaraujo]

Don't know if there is a "correct way". I used Closure.

If your attribute is part of an array you gonna get the index on the second position for example:

'items.*.foo' => 'required'
'items.*.baz' => [
        function (string $attribute, mixed $value, Closure $fail) {
            $index = explode('.', $attribute)[0];
            //lets say this is a Livewire 3 Form that has public $items as the array where you keep the items form data
            if ($this->items[$index]['foo'] == 'bar') {
                $fail("baz is invalid because foo is equals to bar.");
            }
        },
]

[OllieCrook]

Hello! Myself and @Ross2609 just came across this problem!

After lots of source code diving, this can be accomplished with Validator::extendDependent()

This means that when the validator processes the rule and reaches Validator.php Line 524 your rule name will be added to the $dependentRules array on Line 203 allowing the function that makes all of this possible replaceAsterisksInParameters to run!

[YSRoot]

I’ve recently faced a similar problem when working with nested attributes and complex validation logic where a rule needs access to sibling fields — for example, comparing price with discount, or ensuring consistency between related numeric values inside items.*.details.*.

To make such rules cleaner, I ended up extracting a small utility for path manipulation, which I use across multiple custom rules:

<?php

namespace App\Validation\Support;

use Arr;

final readonly class AttributePath
{
    /**
     * Replaces wildcard segments (`*`) in a pattern path
     * with actual segments from a given attribute, while their structure matches.
     *
     * The method iterates synchronously through both pattern and attribute segments,
     * substituting each `*` with the corresponding segment.
     * Once the paths diverge (for example, segment names differ),
     * substitution stops and the rest of the pattern remains unchanged.
     *
     * Used to resolve a pattern path into a specific key
     * that can be used to access real data.
     *
     * @param  string    $pattern     The pattern path containing wildcards (e.g., "orders.*.details.discount").
     * @param  string    $attribute   The actual attribute path being validated (e.g., "orders.3.details.price").
     * @param  float|int $depth       How many `*` segments should be replaced (default — all).
     * @return string                 The concrete path with replaced wildcards (e.g., "orders.3.details.discount").
     *
     * Examples:
     * <code>
     * AttributePath::concretize(pattern: 'orders.*.details.discount', attribute: 'orders.3.details.price');
     * // orders.3.details.discount
     * </code>
     * <code>
     * AttributePath::concretize(pattern: 'invoices.*.items.*.price', attribute: 'invoices.1.items.4.total');
     * // invoices.1.items.4.price
     * </code>
     * <code>
     * AttributePath::concretize(pattern: 'products.*.name', attribute: 'products.10.details.name.value');
     * // products.10.name
     * </code>
     * <code>
     * AttributePath::concretize(pattern: 'orders.attributes.meta', attribute: 'orders.attributes.meta');
     * // orders.attributes.meta
     * </code>
     * <code>
     * AttributePath::concretize(pattern: 'invoices.*.items.*.price', attribute: 'invoices.1.items.4.total', depth: 1);
     * // invoices.1.items.*.price   ← only the first `*` is replaced
     * </code>
     * <code>
     * AttributePath::concretize('orders.*.details.discount.*.value', 'orders.3.details.price.value');
     * // → orders.3.details.discount.*.value
     * </code>
     * <code>
     * AttributePath::concretize('orders.*.details.discount.*.value', 'orders.3.items.total.4.test');
     * // → orders.3.details.discount.*.value
     * </code>
     */
    public static function concretize(string $pattern, string $attribute, float|int $depth = INF): string
    {
        $patternParts = explode('.', $pattern);
        $attrParts    = explode('.', $attribute);

        $resolved      = [];
        $replacedCount = 0;

        while ($patternParts) {
            $part = array_shift($patternParts);
            $attr = array_shift($attrParts);

            // Replace `*` if allowed
            if ($part === '*' && $replacedCount < $depth) {
                $resolved[] = $attr ?? '*';
                $replacedCount++;
                continue;
            }

            // Stop substitution once a mismatch is found
            if ($attr !== $part) {
                array_push($resolved, $part, ...$patternParts);
                break;
            }

            // Matching segment — keep as is
            $resolved[] = $part;
        }

        return implode('.', $resolved);
    }

    /**
     * Converts a concrete attribute path into a pattern path
     * by replacing numeric indices with wildcard segments (`*`).
     *
     * This is the inverse operation of {@see concretize()} —
     * used to derive a generic pattern from a specific attribute path.
     *
     * Example:
     *  - input:  "orders.3.details.discount"
     *  - output: "orders.*.details.discount"
     *
     * @param  string     $attribute  The concrete attribute path, e.g., "orders.3.details.discount".
     * @param  int|float  $depth      How many numeric segments to replace (INF — all).
     * @return string                 The generalized path with wildcards.
     *
     * <code>
     * AttributePath::patternize(attribute: 'orders.3.details.discount');
     * // orders.*.details.discount
     * </code>
     *
     * <code>
     * AttributePath::patternize(attribute: 'invoices.2.items.5.price');
     * // invoices.*.items.*.price
     * </code>
     *
     * <code>
     * AttributePath::patternize(attribute: 'carts.1.packages.4.products.9.name', depth: 2);
     * // carts.*.packages.*.products.9.name
     * </code>
     */
    public static function patternize(string $attribute, float|int $depth = INF): string
    {
        $parts    = explode('.', $attribute);
        $resolved = [];
        $replaced = 0;

        while ($parts) {
            $part = array_shift($parts);
            if ($replaced >= $depth) {
                array_push($resolved, $part, ...$parts);
                break;
            }

            if (is_numeric($part)) {
                $resolved[] = '*';
                $replaced++;
                continue;
            }

            $resolved[] = $part;
        }

        return implode('.', $resolved);
    }

    /**
     * Builds a "sibling" attribute path by replacing one of the segments
     * (by default, the last one) with another segment or sequence of segments.
     *
     * Useful for deriving related attributes, for example,
     * getting "discount" from "orders.0.details.price".
     *
     * @param  string        $attribute          The current attribute path (e.g., "orders.0.details.price").
     * @param  string|array  $replace            The new segment(s) to insert.
     *                                           A string replaces a single segment;
     *                                           an array inserts multiple segments.
     * @param  string|null   $segmentToReplace   Optionally, the name of the segment to replace.
     *                                           If omitted, the last segment is replaced.
     * @return string                            The resulting sibling attribute path.
     *
     * <code>
     * AttributePath::sibling('orders.0.details.price', 'discount');
     * // "orders.0.details.discount"
     * </code>
     * <code>
     * AttributePath::sibling('invoice.details.price', 'total', 'details');
     * // "invoice.total.price"
     * </code>
     * <code>
     * AttributePath::sibling('cart.0.summary.value', ['totals', 'currency']);
     * // "cart.0.summary.totals.currency"
     * </code>
     * <code>
     * AttributePath::sibling('attributes.2.metadata.5.value', 'code', 'value');
     * // "attributes.2.metadata.5.code"
     * </code>
     */
    public static function sibling(string $attribute, string|array $replace, ?string $segmentToReplace = null): string
    {
        $parts = explode('.', $attribute);

        if ($segmentToReplace) {
            $pos = array_search($segmentToReplace, $parts, true);
            if ($pos !== false) {
                $parts[$pos] = $replace;
            }
            return implode('.', $parts);
        }

        // Replace the last segment by default
        array_pop($parts);
        $parts = array_merge($parts, Arr::wrap($replace));

        return implode('.', $parts);
    }
}

This helper lets a rule dynamically resolve related fields like:

$attribute = 'items.3.details.price';
AttributePath::sibling($attribute, 'discount');
// → "items.3.details.discount"

$attribute = 'items.3.details.price';
AttributePath::concretize('items.*.details.discount', $attribute);
// → "items.3.details.discount"

$attribute = 'items.5.details.price';
AttributePath::patternize($attribute);
// → "items.*.details.price"

Example usage in a custom rule

Here’s a simple example of a rule that ensures discount is not greater than price for each item.
It implements both Rule and DataAwareRule, and uses the helper above to access sibling values.

<?php

namespace App\Rules;

use Illuminate\Contracts\Validation\DataAwareRule;
use Illuminate\Contracts\Validation\Rule;
use App\Validation\Support\AttributePath;

class DiscountLessThanPrice implements Rule, DataAwareRule
{
    protected array $data = [];

    public function setData($data)
    {
        $this->data = $data;
        return $this;
    }

    public function passes($attribute, $value): bool
    {
        // Build path to the "price" field next to the current "discount"
        $pricePath = AttributePath::sibling($attribute, 'price');

        $price = data_get($this->data, $pricePath);

        // If price is missing — ignore (let other rules handle it)
        if ($price === null) {
            return true;
        }

        return (float) $value <= (float) $price;
    }

    public function message(): string
    {
        return __('The :attribute must be less than or equal to its corresponding price.');
    }
}

That way, your validation rules can stay self-contained and expressive,
while still understanding the context of nested structures —
especially when validating arrays like items.*.details.*.

In addition:

The other two methods — concretize() and patternize() — are also very useful inside custom validation rules that implement DataAwareRule.

For example:
• concretize() helps resolve a pattern key like items.*.fields.*.value into the exact attribute being validated (items.3.fields.2.value),
which is handy when building error messages or linking related fields dynamically.
• patternize() does the opposite — it converts the current attribute path back into a reusable pattern,
which can be useful when referencing validation rules, merging errors, or logging the general attribute structure.

Both are great for writing context-aware, reusable validation rules that can operate on nested request data
without hardcoding paths or depending on manual string manipulations.

[aedart]

This does look nice. But I do wonder if its a bit "overkill". I mean that Laravel's validator, internally at least, will replace * with an index. It would be so nice, if that index could be forwarded to closures and custom validation rules, ...etc. Not sure how to do so, but this might be grounds for creating a pull request and try to add such a feature.

[bilfeldt]

See for example this awesome validation rule which only works properly when used as a string, not as an object:

use Illuminate\Support\Facades\Validator;

$validator = Validator::make(
  data: [
    'contacts' => [
      ['phone' => '8 406 75 00', 'country' => 'SE'], // Valid (Danish embassy in Sweden)
      ['phone' => '9 684 1050', 'country' => 'FI'], // Valid (Danish embassy in Finland)
    ]
  ],
  rules: [
    'contacts.*.phone' => [
      // 'phone:contacts.*.country', // works
      (new \Propaganistas\LaravelPhone\Rules\Phone)->countryField('contacts.*.country'), // fails
    ],
  ]
)->errors()

This seems to be the PR #18654 adding support for it for string based validation rules, but how is it done for objects? 🤔

[bilfeldt]

Here is the solution I ended up with.

Validation Rule

class Example implements DataAwareRule, ValidationRule
{
    /**
     * All of the data under validation.
     *
     * @var array<string, mixed>
     */
    protected $data = [];

    public function __construct(
        protected string $dependentField,
    ) {}

    /**
     * Set the data under validation.
     *
     * @param  array<string, mixed>  $data
     */
    public function setData(array $data): static
    {
        $this->data = $data;

        return $this;
    }

    /**
     * Run the validation rule.
     *
     * @param  \Closure(string, ?string=): \Illuminate\Translation\PotentiallyTranslatedString  $fail
     */
    public function validate(string $attribute, mixed $value, Closure $fail): void
    {
        $dependentFieldValue = $this->getDependentFieldValue($attribute);

        // validation logic here
    }

    protected function getDependentFieldValue(string $attribute): mixed
    {
        // Using Arr::get() enables support for nested data.
        // dependent field can be: contacts.*.foo
        // while the attribute under validation is: contacts.0.bar
        // to we extract the value from $this->data['contacts'][0]['bar']
        return Arr::get($this->data, Str::replaceIndexes($this->dependentField, $attribute));
    }
}

Now this require use of a macro Str::replaceIndexes()to replace indexes.

String macro

<?php

declare(strict_types=1);

namespace App\Macros\Str;

class ReplaceIndexes
{
    /**
     * Replace wildcards (*) in a dot notation target path with corresponding indexes from a source path.
     *
     * This is useful when you have a template path with wildcards and need to populate it
     * with actual indexes from a specific nested array element path.
     *
     * Example:
     * Str::replaceIndexes(
     *     'data.*.posts.*.author.country',
     *     'data.1.posts.2.author.addresses.3.phone'
     * )
     * // Returns: 'data.1.posts.2.author.country'
     *
     * @return \Closure(string $target, string $source): string
     */
    public function __invoke(): \Closure
    {
        return function (string $target, string $source): string {
            /**
             * @var \Illuminate\Support\Str $this
             */
            $targetSegments = explode('.', $target);
            $sourceSegments = explode('.', $source);

            $capturedIndexes = [];

            // Walk through target segments and match against source
            foreach ($targetSegments as $key => $targetSegment) {
                $sourceSegment = $sourceSegments[$key] ?? null;

                if ($targetSegment === '*') {
                    $capturedIndexes[] = $sourceSegment;
                } elseif ($targetSegment !== $sourceSegment) {
                    // Abort
                    break;
                }
            }

            // Replace wildcards in target with captured indexes
            $result = $target;
            foreach ($capturedIndexes as $index) {
                $result = preg_replace('/\*/', $index, $result, 1);
            }

            return $result;
        };
    }
}

[aedart]

@bilfeldt that is a very elegant solution. I might actually adapt it for some of my projects :)
However, I still feel like this is something that Laravel's validator, somehow, should be able to provide out-of-the-box. Sadly I haven't got much time lately to investigate where this kind of logic could be added, in such a way that custom validation rules (or closures) could gain access to the correct dependent field's value, via the appropriate index.

If you have a good grasp of the Validator's internal mechanisms, perhaps you might see a place where it makes sense to expand it. I'm sure that the Laravel team would welcome such a nice feature, as it can be of benefit to many developers.