Allow stacking inheritance for rules

Author: bradenkeith

docs/docs/usage/attributes.md

@@ -91,6 +91,34 @@ By default the attribute also applies the inherited rules when the Data class va
 public ?string $postal_code,
 ```
 
+### Runtime Validation
+
+When runtime enforcement is enabled (default), the attribute hooks into Spatie Data’s validator so any request payload must satisfy the inherited rules. This keeps schema generation and runtime validation perfectly in sync.
+
+### Combining with Local Rules
+
+Inherited rules are merged with rules defined on the consuming class. If you add stricter requirements locally—such as making a field required—they stack on top of the inherited rules:
+
+```php
+#[ValidationSchema]
+class FranchiseUpdateData extends Data
+{
+    public function __construct(
+        #[InheritValidationFrom(PostalCodeValidator::class, 'postal_code')]
+        public ?string $postal_code,
+    ) {}
+
+    public static function rules(?ValidationContext $context = null): array
+    {
+        return [
+            'postal_code' => ['required'],
+        ];
+    }
+}
+```
+
+The generated schema now reflects both sets of rules and the runtime validator enforces them together.
+
 ### Field Mapping
 
 You can inherit validation from a differently named field:

src/Resolvers/InheritingDataValidationRulesResolver.php

@@ -12,6 +12,8 @@
 use Spatie\LaravelData\Support\Validation\RuleNormalizer;
 use Spatie\LaravelData\Support\Validation\ValidationPath;
 
+use function in_array;
+use function is_string;
 use function str_starts_with;
 
 class InheritingDataValidationRulesResolver extends BaseResolver
@@ -118,7 +120,8 @@ protected function copyRulesToTargetProperty(
 
         foreach ($sourceRules as $key => $rules) {
             if ($key === $sourceProperty) {
-                $dataRules->add($basePath->property($targetProperty), $rules);
+                $targetPath = $basePath->property($targetProperty);
+                $this->mergeIntoDataRules($dataRules, $targetPath, $rules);
 
                 continue;
             }
@@ -132,10 +135,45 @@ protected function copyRulesToTargetProperty(
             $targetKey = $targetProperty.$suffix;
             $fullKey = $baseKey ? "{$baseKey}.{$targetKey}" : $targetKey;
 
-            $dataRules->add(
+            $this->mergeIntoDataRules(
+                $dataRules,
                 ValidationPath::create($fullKey),
                 $rules
             );
         }
     }
+
+    protected function mergeIntoDataRules(
+        DataRules $dataRules,
+        ValidationPath $path,
+        array $rules
+    ): void {
+        $key = $path->get();
+
+        if ($key === null) {
+            return;
+        }
+
+        $existing = $dataRules->rules[$key] ?? [];
+        $merged = $this->mergeRuleSet($existing, $rules);
+
+        $dataRules->add($path, $merged);
+    }
+
+    protected function mergeRuleSet(array $existing, array $incoming): array
+    {
+        foreach ($incoming as $rule) {
+            if (is_string($rule)) {
+                if (! in_array($rule, $existing, true)) {
+                    $existing[] = $rule;
+                }
+
+                continue;
+            }
+
+            $existing[] = $rule;
+        }
+
+        return $existing;
+    }
 }

src/Services/DataClassRuleProcessor.php

@@ -19,6 +19,8 @@
 use Spatie\LaravelData\Support\Validation\RuleDenormalizer;
 use Spatie\LaravelData\Support\Validation\ValidationContext;
 use Spatie\LaravelData\Support\Validation\ValidationPath;
+use function in_array;
+use function is_string;
 
 /**
  * Service for processing Data class validation rules
@@ -296,9 +298,11 @@ protected function processInheritedValidation(
 
                 // Find the source property rules
                 if (isset($sourceRules[$sourceProperty])) {
-                    // Override the current property's rules with inherited ones
-                    $dataRules->add(
-                        $path->property($currentPropertyName),
+                    $propertyPath = $path->property($currentPropertyName);
+
+                    $this->mergeRulesIntoDataRules(
+                        $dataRules,
+                        $propertyPath,
                         $sourceRules[$sourceProperty]
                     );
 
@@ -331,6 +335,46 @@ protected function processInheritedValidation(
         }
     }
 
+    /**
+     * Merge a new set of rules into the DataRules collection for a given path.
+     */
+    protected function mergeRulesIntoDataRules(
+        DataRules $dataRules,
+        ValidationPath $path,
+        array $rules
+    ): void {
+        $key = $path->get();
+
+        if ($key === null) {
+            return;
+        }
+
+        $existing = $dataRules->rules[$key] ?? [];
+        $merged = $this->mergeRuleSet($existing, $rules);
+
+        $dataRules->add($path, $merged);
+    }
+
+    /**
+     * Merge two rule arrays, avoiding duplicate string rules.
+     */
+    protected function mergeRuleSet(array $existing, array $incoming): array
+    {
+        foreach ($incoming as $rule) {
+            if (is_string($rule)) {
+                if (! in_array($rule, $existing, true)) {
+                    $existing[] = $rule;
+                }
+
+                continue;
+            }
+
+            $existing[] = $rule;
+        }
+
+        return $existing;
+    }
+
     public function getSchemaOverridesForClass(string $className): array
     {
         return $this->schemaOverridesByClass[$className] ?? [];

tests/Fixtures/DataClasses/InheritedPostalCodeWithLocalRulesData.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RomegaSoftware\LaravelSchemaGenerator\Tests\Fixtures\DataClasses;
+
+use RomegaSoftware\LaravelSchemaGenerator\Attributes\InheritValidationFrom;
+use RomegaSoftware\LaravelSchemaGenerator\Attributes\ValidationSchema;
+use Spatie\LaravelData\Data;
+use Spatie\LaravelData\Support\Validation\ValidationContext;
+
+#[ValidationSchema]
+class InheritedPostalCodeWithLocalRulesData extends Data
+{
+    public function __construct(
+        #[InheritValidationFrom(PostalCodeMethodRulesData::class, 'code')]
+        public ?string $postal_code,
+    ) {}
+
+    /**
+     * @return array<string, array<int, string>>
+     */
+    public static function rules(?ValidationContext $validationContext = null): array
+    {
+        return [
+            'postal_code' => ['required'],
+        ];
+    }
+}

tests/Fixtures/DataClasses/PostalCodeMethodRulesData.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RomegaSoftware\LaravelSchemaGenerator\Tests\Fixtures\DataClasses;
+
+use RomegaSoftware\LaravelSchemaGenerator\Attributes\ValidationSchema;
+use Spatie\LaravelData\Data;
+use Spatie\LaravelData\Support\Validation\ValidationContext;
+
+#[ValidationSchema]
+class PostalCodeMethodRulesData extends Data
+{
+    public function __construct(
+        public ?string $code,
+    ) {}
+
+    /**
+     * @return array<string, array<int, string>>
+     */
+    public static function rules(?ValidationContext $validationContext = null): array
+    {
+        return [
+            'code' => ['string', 'regex:/^\\d{5}(-\\d{4})?$/'],
+        ];
+    }
+}

tests/Integration/RuntimeInheritedValidationTest.php

@@ -7,6 +7,7 @@
 use PHPUnit\Framework\Attributes\Test;
 use RomegaSoftware\LaravelSchemaGenerator\Tests\Fixtures\DataClasses\InheritedPostalCodeData;
 use RomegaSoftware\LaravelSchemaGenerator\Tests\Fixtures\DataClasses\InheritedPostalCodeRuntimeDisabledData;
+use RomegaSoftware\LaravelSchemaGenerator\Tests\Fixtures\DataClasses\InheritedPostalCodeWithLocalRulesData;
 use RomegaSoftware\LaravelSchemaGenerator\Tests\TestCase;
 use Spatie\LaravelData\Resolvers\DataValidatorResolver;
 
@@ -47,4 +48,27 @@ public function it_can_disable_runtime_inheritance_per_attribute(): void
         );
         $this->assertFalse($invalid->fails());
     }
+
+    #[Test]
+    public function it_merges_local_rules_with_inherited_rules_at_runtime(): void
+    {
+        $resolver = $this->app->make(DataValidatorResolver::class);
+
+        $missing = $resolver->execute(InheritedPostalCodeWithLocalRulesData::class, []);
+        $this->assertTrue($missing->fails());
+        $this->assertArrayHasKey('Required', $missing->failed()['postal_code']);
+
+        $invalid = $resolver->execute(
+            InheritedPostalCodeWithLocalRulesData::class,
+            ['postal_code' => '123']
+        );
+        $this->assertTrue($invalid->fails());
+        $this->assertArrayHasKey('Regex', $invalid->failed()['postal_code']);
+
+        $valid = $resolver->execute(
+            InheritedPostalCodeWithLocalRulesData::class,
+            ['postal_code' => '12345']
+        );
+        $this->assertFalse($valid->fails());
+    }
 }

tests/Integration/SchemaInheritanceMergeTest.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RomegaSoftware\LaravelSchemaGenerator\Tests\Integration;
+
+use PHPUnit\Framework\Attributes\Test;
+use ReflectionClass;
+use RomegaSoftware\LaravelSchemaGenerator\Tests\Fixtures\DataClasses\InheritedPostalCodeWithLocalRulesData;
+use RomegaSoftware\LaravelSchemaGenerator\Tests\TestCase;
+use RomegaSoftware\LaravelSchemaGenerator\Tests\Traits\InteractsWithExtractors;
+
+class SchemaInheritanceMergeTest extends TestCase
+{
+    use InteractsWithExtractors;
+
+    #[Test]
+    public function it_merges_local_rules_with_inherited_rules_for_schema_generation(): void
+    {
+        $extractor = $this->getDataExtractor();
+        $extracted = $extractor->extract(new ReflectionClass(InheritedPostalCodeWithLocalRulesData::class));
+
+        $postalProperty = $extracted->properties->firstWhere('name', 'postal_code');
+
+        $this->assertNotNull($postalProperty);
+        $this->assertFalse($postalProperty->isOptional);
+        $this->assertTrue($postalProperty->validations?->isFieldRequired());
+    }
+}