Why does form level validate errors not propagate down to fieldState.error for given field

[rfsmart-psimoneau]

at the form level I have tried using the new validate Api...

useForm({
   validate: () => {
      return {
         myField: {
            message: 'Some validation failed'
         }
      }
   }
})

I would expect the fieldState error for my field to reflect this error, but it is only available through formState.errors.form.myField

const {  fieldState: { error }}  = useController({
   name: 'myField'
})

this error is undefined and I can only access it like this instead

const {  formState: { errors: { form: { ['myField']: error } }}  = useController({
   name: 'myField'
})

so now i have field level validation rules and form level validation rules, but I would expect them to both propagate down the fieldState error. In addition typescript complains about this because the 'form' property on formState.errors.form comes back as Partial<{ type, message >} instead of a Record<string, Partial<{ type, message }>

am I missing something , What is the point of returning field level errors from the form level validation if they arent proagating the error down to the field.

[Alox1d]

The current implementation puts errors returned by useForm({ validate }) under errors.form. Your myField therefore becomes errors.form.myField, while that field's controller reads errors.myField.

If the error belongs to the field, use its rules.validate. That callback receives all form values too, so you can still do cross-field validation there. A resolver returning errors at the field paths is another option. Implementation.

[DahanItamar]

The TypeScript complaint about errors.form.myField is a declaration mismatch: form-level validation stores an error map there, while FieldErrors.form currently exposes only a single GlobalError.

I've submitted a scoped type fix in #13860, with a regression that fails on the original declarations. All type checks, 1,552 unit tests and 90 browser tests passed locally; the PR's six CI checks also passed. It still needs maintainer review.

The field-state behavior described above remains a separate API-design question. The proposed type fix makes the existing errors.form.myField access compile. In the current API, getErrors('form.myField') already reads that path with a typed return value; retain your usual form-state subscription when using it during rendering.

[mustaphaelou]

That's by design, not a bug: the form-level validate API surfaces its errors under formState.errors.form, e.g. formState.errors.form.myField, so useController(...).fieldState.error (which maps to formState.errors[name]) stays undefined.

From the docs (useForm validate, v7.72.0): returning { [fieldName]: { type, message } } surfaces each entry at formState.errors.form.<fieldName>.

Options:

• Read the form-level error where you need it:

  const { formState: { errors } } = useForm(...);
  const formError = errors.form?.myField;

• Or bridge it into the field-level shape with setError inside your form-level validate (or in an effect), so fieldState.error picks it up.
• Note validate and resolver are mutually exclusive — only the resolver runs if both are set.

So your observation is expected; use errors.form.myField or call setError("myField", ...) if you need fieldState.error.

If this clears it up, please mark this comment as the answer — thanks!