Support for enum error messages

Author: bradenkeith

src/Data/ResolvedValidationSet.php

@@ -70,23 +70,31 @@ public static function make(
      */
     public function hasValidation(string $rule): bool
     {
-        return $this->validations->toCollection()->first(fn (ResolvedValidation $v) => $v->rule === $rule) !== null;
+        return $this->getValidation($rule) !== null;
     }
 
     /**
      * Get a specific validation by rule name
      */
     public function getValidation(string $rule): ?ResolvedValidation
     {
-        return $this->validations->toCollection()->first(fn (ResolvedValidation $v) => $v->rule === $rule);
+        $normalizedRule = strtolower($rule);
+
+        return $this->validations
+            ->toCollection()
+            ->first(fn (ResolvedValidation $v) => strtolower($v->rule) === $normalizedRule);
     }
 
     /**
      * Get all validations with a specific rule name (for rules that can appear multiple times)
      */
     public function getValidations(string $rule): Collection
     {
-        return $this->validations->toCollection()->filter(fn (ResolvedValidation $v) => $v->rule === $rule);
+        $normalizedRule = strtolower($rule);
+
+        return $this->validations
+            ->toCollection()
+            ->filter(fn (ResolvedValidation $v) => strtolower($v->rule) === $normalizedRule);
     }
 
     /**

src/Services/MessageResolutionService.php

@@ -68,11 +68,10 @@ public function resolveCustomMessage(): string
             throw new \InvalidArgumentException('The field, rule name, and validator must be set using with() prior to calling resolveCustomMessage.');
         }
 
-        // Check for custom message first
-        $customMessageKey = $this->field.'.'.lcfirst($this->ruleName);
+        $customMessage = $this->findCustomMessageForRule();
 
-        if (isset($this->validator->customMessages[$customMessageKey])) {
-            return $this->validator->customMessages[$customMessageKey];
+        if ($customMessage !== null) {
+            return $customMessage;
         }
 
         // Fall back to default Laravel message
@@ -252,6 +251,47 @@ private function applyMessageReplacements(string $message, array $parameters): s
         return $this->ensureDisplayableAttribute($replaced);
     }
 
+    /**
+     * Locate a custom message for the current rule, including known aliases.
+     */
+    private function findCustomMessageForRule(): ?string
+    {
+        foreach ($this->possibleCustomMessageKeys() as $customMessageKey) {
+            if (isset($this->validator->customMessages[$customMessageKey])) {
+                return $this->validator->customMessages[$customMessageKey];
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Build the list of possible custom message keys to check.
+     */
+    private function possibleCustomMessageKeys(): array
+    {
+        $baseRule = lcfirst($this->ruleName);
+        $keys = [$this->field.'.'.$baseRule];
+
+        foreach ($this->getRuleMessageAliases($baseRule) as $alias) {
+            $keys[] = $this->field.'.'.$alias;
+        }
+
+        return array_values(array_unique($keys));
+    }
+
+    /**
+     * Return aliases for a validation rule where Laravel normalizes the rule name.
+     */
+    private function getRuleMessageAliases(string $ruleName): array
+    {
+        return match (strtolower($ruleName)) {
+            'in' => ['enum'],
+            'enum' => ['in'],
+            default => [],
+        };
+    }
+
     private function ensureDisplayableAttribute(string $message): string
     {
         $displayable = $this->getDisplayableAttribute();

src/TypeHandlers/EnumTypeHandler.php

@@ -57,10 +57,18 @@ public function handle(SchemaPropertyData $property): BuilderInterface
         }
 
         // Check for enum error messages
-        if (str_starts_with($type, 'enum:') && $validations->getMessage('enum')) {
-            $builder->message($validations->getMessage('enum'));
-        } elseif ($validations->hasValidation('in') && $validations->getMessage('in')) {
-            $builder->message($validations->getMessage('in'));
+        $enumMessage = null;
+
+        if (str_starts_with($type, 'enum:')) {
+            $enumMessage = $validations->getMessage('Enum');
+        }
+
+        if ($enumMessage === null && $validations->hasValidation('In')) {
+            $enumMessage = $validations->getMessage('In');
+        }
+
+        if ($enumMessage !== null) {
+            $builder->message($enumMessage);
         }
 
         // Handle nullable

tests/Feature/EnumZodGenerationTest.php

@@ -5,6 +5,7 @@
 use PHPUnit\Framework\Attributes\Test;
 use RomegaSoftware\LaravelSchemaGenerator\Extractors\RequestClassExtractor;
 use RomegaSoftware\LaravelSchemaGenerator\Generators\ValidationSchemaGenerator;
+use RomegaSoftware\LaravelSchemaGenerator\Tests\Fixtures\FormRequests\EnumWithCustomMessageRequest;
 use RomegaSoftware\LaravelSchemaGenerator\Tests\Fixtures\FormRequests\UnifiedValidationRequest;
 use RomegaSoftware\LaravelSchemaGenerator\Tests\TestCase;
 use RomegaSoftware\LaravelSchemaGenerator\Tests\Traits\InteractsWithExtractors;
@@ -35,4 +36,18 @@ public function it_generates_z_enum_for_laravel_enum_rule(): void
         $this->assertStringNotContainsString('status: z.enum(["pending", "approved", "rejected"], { message: "The metadata.status field is required." }).optional()', $schema,
             'Required status field should not be optional');
     }
+
+    #[Test]
+    public function it_uses_custom_messages_for_enum_rules(): void
+    {
+        $reflection = new \ReflectionClass(EnumWithCustomMessageRequest::class);
+        $extracted = $this->getRequestExtractor()->extract($reflection);
+        $schema = $this->generator->generate($extracted);
+
+        $this->assertStringContainsString(
+            'status: z.enum(["pending", "active", "inactive", "deleted"], { message: "Please choose a valid state from the available options." }).nullable().optional()',
+            $schema,
+            'Enum fields should include custom messages defined on the form request'
+        );
+    }
 }

tests/Fixtures/Expected/unified-schemas.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 
 export const UnifiedValidationRequestSchema = z.object({
-    auth_type: z.enum(["password", "otp"]),
+    auth_type: z.enum(["password", "otp"], { message: "The selected auth type is invalid." }),
     attachments: z.array(z.object({ file: z.file().mime(['image/jpeg', 'image/png', 'application/pdf'], 'The attachments.*.file field must be a file of type: jpg, png, pdf, attachments.*.file.').max(5242880, 'The attachments.*.file field must not be greater than 5120 kilobytes.'), description: z.string().max(255, 'The attachments.*.description field must not be greater than 255 characters.').trim().nullable().optional() })).nullable().optional(),
     credentials: z.object({ email: z.email({ error: 'The credentials.email field must be a valid email address.' }).trim().min(1, 'Email is required.').max(255, 'The credentials.email field must not be greater than 255 characters.'), password: z.string().min(8, 'The credentials.password field must be at least 8 characters.').trim().nullable().optional(), otp: z.number().refine((val) => {const str = String(Math.abs(Math.floor(val))); return str.length === 6; }, { message: 'The credentials.otp field must be 6 digits.' }).nullable().optional() }).optional(),
     profile: z.object({ name: z.string({ error: 'The profile.name field is required.' }).trim().refine((val) => val != undefined && val != null && val != '', { error: 'The profile.name field is required.' }).min(1, 'The profile.name field is required.').max(150, 'The profile.name field must not be greater than 150 characters.'), bio: z.string().max(500, 'The profile.bio field must not be greater than 500 characters.').trim().nullable().optional(), website: z.preprocess((val) => (val === '' ? undefined : val), z.url({ error: 'The profile.website field must be a valid URL.' }).nullable().optional()), timezone: z.string({ error: 'The profile.timezone field is required.' }).trim().refine((val) => val != undefined && val != null && val != '', { error: 'The profile.timezone field is required.' }).min(1, 'The profile.timezone field is required.'), preferences: z.object({ accepted_terms: z.string().refine((val) => { if (val === undefined || val === null) { return false; } if (typeof val === "string") { const normalized = val.toLowerCase(); if (normalized === "yes" || normalized === "on" || normalized === "true" || normalized === "1") { return true; } } return val === true || val === 1; }, { message: 'You must accept the terms.' }).trim().optional(), tags: z.array(z.enum(["news", "updates", "offers"])).min(1, 'The profile.preferences.tags field must have at least 1 items.').max(5, 'The profile.preferences.tags field must not have more than 5 items.').refine((values) => { if (!Array.isArray(values)) { return true; } const ignoreCase = false; const strict = false; for (let i = 0; i < values.length; i++) {     for (let j = i + 1; j < values.length; j++) {         const left = values[i];         const right = values[j];         if (ignoreCase && typeof left === "string" && typeof right === "string") {             if (left.localeCompare(right, undefined, { sensitivity: "accent" }) === 0) {                 return false;             }             continue;         }         if (strict ? left === right : left == right) {             return false;         }     } } return true; }, { message: 'The profile.preferences.tags field has a duplicate value.' }).optional() }).optional(), contacts: z.array(z.object({ email: z.email({ error: 'The profile.contacts.*.email field must be a valid email address.' }).trim().min(1, 'The profile.contacts.*.email field is required.'), phone: z.string().trim().nullable().optional(), label: z.enum(["primary", "backup"], { message: "The profile.contacts.*.label field is required." }) })).min(1, 'The profile.contacts field must have at least 1 items.').optional(), address: z.object({ street: z.string({ error: 'The profile.address.street field is required.' }).trim().refine((val) => val != undefined && val != null && val != '', { error: 'The profile.address.street field is required.' }).min(1, 'The profile.address.street field is required.'), city: z.string({ error: 'The profile.address.city field is required.' }).trim().refine((val) => val != undefined && val != null && val != '', { error: 'The profile.address.city field is required.' }).min(1, 'The profile.address.city field is required.'), postal_code: z.string({ error: 'The profile.address.postal code field is required.' }).trim().refine((val) => val != undefined && val != null && val != '', { error: 'The profile.address.postal code field is required.' }).min(1, 'The profile.address.postal code field is required.').regex(/^[0-9]{5}$/, 'Postal code must be exactly 5 digits.'), country: z.string({ error: 'The profile.address.country field is required.' }).trim().refine((val) => val != undefined && val != null && val != '', { error: 'The profile.address.country field is required.' }).min(1, 'The profile.address.country field is required.').length(2, 'The profile.address.country field must be 2 characters.') }).optional() }).optional(),

tests/Fixtures/FormRequests/EnumWithCustomMessageRequest.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace RomegaSoftware\LaravelSchemaGenerator\Tests\Fixtures\FormRequests;
+
+use Illuminate\Foundation\Http\FormRequest;
+use Illuminate\Validation\Rule;
+use RomegaSoftware\LaravelSchemaGenerator\Attributes\ValidationSchema;
+use RomegaSoftware\LaravelSchemaGenerator\Tests\Fixtures\Enums\TestStatusEnum;
+
+#[ValidationSchema(name: 'EnumWithCustomMessageRequestSchema')]
+class EnumWithCustomMessageRequest extends FormRequest
+{
+    public function rules(): array
+    {
+        return [
+            'status' => ['nullable', Rule::enum(TestStatusEnum::class)],
+        ];
+    }
+
+    public function messages(): array
+    {
+        return [
+            'status.enum' => 'Please choose a valid state from the available options.',
+        ];
+    }
+
+    public function authorize(): bool
+    {
+        return true;
+    }
+}

tests/Integration/EnumValidationIntegrationTest.php

@@ -41,10 +41,10 @@ public function test_enum_validation_consistency_between_root_and_nested()
         $schema = $this->generator->generate($extracted, 'TestRequestWithRootEnumSchema');
 
         // Root level enum should be properly formatted (using double quotes as per Zod standard)
-        $this->assertStringContainsString('payment_method: z.enum(["credit_card", "paypal", "bank_transfer"])', $schema);
+        $this->assertStringContainsString('payment_method: z.enum(["credit_card", "paypal", "bank_transfer"], { message: "The selected payment method is invalid." })', $schema);
 
         // Nested enum should also be properly formatted
-        $this->assertStringContainsString('component: z.enum(["base", "tax", "discount"]', $schema);
+        $this->assertStringContainsString('component: z.enum(["base", "tax", "discount"], { message: "The items.*.pricing.*.component field is required." })', $schema);
 
         // Should NOT contain malformed enum
         $this->assertStringNotContainsString('z.enum(App.', $schema);
@@ -72,7 +72,7 @@ public function rules(): array
         $schema = $this->generator->generate($extracted, 'StatusEnumSchema');
 
         // Should generate enum correctly even without required|string
-        $this->assertStringContainsString('status: z.enum(["active", "inactive", "pending"])', $schema);
+        $this->assertStringContainsString('status: z.enum(["active", "inactive", "pending"], { message: "The selected status is invalid." })', $schema);
     }
 
     #[Test]
@@ -93,6 +93,6 @@ public function rules(): array
         $schema = $this->generator->generate($extracted, 'PriorityEnumSchema');
 
         // Should generate enum correctly with required
-        $this->assertStringContainsString('priority: z.enum(["low", "medium", "high"])', $schema);
+        $this->assertStringContainsString('priority: z.enum(["low", "medium", "high"], { message: "The selected priority is invalid." })', $schema);
     }
 }