Skip to content
Source
Sign inSign up
TanStack/form
Open History to see the last commit

fieldDebugCases.test.ts

303 lines8.4 KB

1import {
2 InternalFormApi,
3 InternalFormGroupApi,
4} from '@tanstack/form-core/internals'
5import { describe, expect, it } from 'vitest'
6import { z } from 'zod'
7import { getFieldDebugSuspicions } from '../src/bridge/fields/fieldDebug'
8import { setFieldValidatorErrors } from './testUtils'
9import type { AnyInternalFieldApi } from '@tanstack/form-core/internals'
10import type { FieldDebugCase } from '../src/bridge/fields/fieldDebug'
11​
12const callbackValidator = {
13 triggers: ['change'] as const,
14 run: () => null,
16​
17const emptyTriggerValidator = {
18 triggers: [] as [],
19 run: () => null,
21​
22const schemaValidator = {
23 triggers: ['change'] as const,
24 run: z.unknown(),
26​
27function setFieldError(field: AnyInternalFieldApi) {
28 setFieldValidatorErrors(field, [{ message: 'Invalid' }])
30​
31describe('field debug cases', () => {
32 it('reports empty-trigger field and form validators in pipeline order', () => {
33 const form = new InternalFormApi({
34 defaultValues: { name: '' },
35 validators: [
36 emptyTriggerValidator,
37 callbackValidator,
38 emptyTriggerValidator,
39 ] as never,
40 })
41 const field = form._getOrCreateFieldApi({
42 name: 'name',
43 validators: [
44 callbackValidator,
45 emptyTriggerValidator,
46 {
47 ...emptyTriggerValidator,
48 runOnMount: true,
49 runOnSubmit: false,
50 },
51 ] as never,
52 })
53 const unregister = field._register()
54​
55 try {
56 expect(getFieldDebugSuspicions({ field })).toEqual([
57 {
58 kind: 'validators-without-triggers',
59 evidence: {
60 fieldPath: 'name',
61 validators: [
62 { scope: 'field', validatorIndex: 1 },
63 { scope: 'form', validatorIndex: 0 },
64 { scope: 'form', validatorIndex: 2 },
65 ],
66 },
67 },
68 ])
69 } finally {
70 unregister()
71 }
72 })
73​
74 it('does not report mount-only validators as empty-trigger validators', () => {
75 const form = new InternalFormApi({ defaultValues: { name: '' } })
76 const field = form._getOrCreateFieldApi({
77 name: 'name',
78 validators: [
79 {
80 ...emptyTriggerValidator,
81 runOnMount: true,
82 runOnSubmit: false,
83 },
84 ] as never,
85 })
86 const unregister = field._register()
87​
88 try {
89 expect(getFieldDebugSuspicions({ field })).toEqual([])
90 } finally {
91 unregister()
92 }
93 })
94​
95 it('uses the containing form group instead of form validators', () => {
96 const form = new InternalFormApi({
97 defaultValues: { profile: { name: '' } },
98 validators: [emptyTriggerValidator] as never,
99 })
100 const group = new InternalFormGroupApi({
101 form,
102 name: 'profile',
103 validators: [callbackValidator, emptyTriggerValidator] as never,
104 })
105 const field = form._getOrCreateFieldApi({
106 name: 'profile.name',
107 validators: [emptyTriggerValidator] as never,
108 })
109 const unregister = field._register()
110​
111 try {
112 expect(getFieldDebugSuspicions({ field })).toEqual([
113 {
114 kind: 'validators-without-triggers',
115 evidence: {
116 fieldPath: 'profile.name',
117 validators: [
118 { scope: 'field', validatorIndex: 0 },
119 {
120 scope: 'formGroup',
121 formGroupPath: 'profile',
122 validatorIndex: 1,
123 },
124 ],
125 },
126 },
127 ])
128 } finally {
129 unregister()
130 group._cleanup()
131 }
132 })
133​
134 it('does not fall back to form validators when the group has none', () => {
135 const form = new InternalFormApi({
136 defaultValues: { profile: { contact: { email: '' } } },
137 validators: [emptyTriggerValidator] as never,
138 })
139 const group = new InternalFormGroupApi({
140 form,
141 name: 'profile.contact',
142 })
143 const field = form._getOrCreateFieldApi({
144 name: 'profile.contact.email',
145 validators: [callbackValidator] as never,
146 })
147 const unregister = field._register()
148​
149 try {
150 expect(getFieldDebugSuspicions({ field })).toEqual([])
151 } finally {
152 unregister()
153 group._cleanup()
154 }
155 })
156​
157 it('keeps aggregated schema errors ahead of the empty-trigger tip', () => {
158 const form = new InternalFormApi({
159 defaultValues: {
160 parent: { first: '', nested: { second: '' }, callback: '' },
161 },
162 })
163 const parent = form._getOrCreateFieldApi({
164 name: 'parent',
165 validators: [emptyTriggerValidator] as never,
166 })
167 const first = form._getOrCreateFieldApi({
168 name: 'parent.first',
169 validators: [schemaValidator] as never,
170 })
171 form._getOrCreateFieldApi({ name: 'parent.nested' })
172 const second = form._getOrCreateFieldApi({
173 name: 'parent.nested.second',
174 validators: [schemaValidator] as never,
175 })
176 const callback = form._getOrCreateFieldApi({
177 name: 'parent.callback',
178 validators: [callbackValidator] as never,
179 })
180 const unregisterParent = parent._register()
181​
182 setFieldError(first)
183 setFieldError(second)
184 setFieldError(callback)
185​
186 try {
187 expect(getFieldDebugSuspicions({ field: parent })).toEqual([
188 {
189 kind: 'schema-errors-on-unmounted-descendants',
190 evidence: {
191 fieldPath: 'parent',
192 unmountedDescendantPaths: ['parent.first', 'parent.nested.second'],
193 },
194 },
195 {
196 kind: 'validators-without-triggers',
197 evidence: {
198 fieldPath: 'parent',
199 validators: [{ scope: 'field', validatorIndex: 0 }],
200 },
201 },
202 ])
203 } finally {
204 unregisterParent()
205 }
206 })
207​
208 it('ignores mounted, killed, and callback-only descendants', () => {
209 const form = new InternalFormApi({
210 defaultValues: { parent: { mounted: '', killed: '', callback: '' } },
211 })
212 const parent = form._getOrCreateFieldApi({ name: 'parent' })
213 const mounted = form._getOrCreateFieldApi({
214 name: 'parent.mounted',
215 validators: [schemaValidator] as never,
216 })
217 const killed = form._getOrCreateFieldApi({
218 name: 'parent.killed',
219 validators: [schemaValidator] as never,
220 })
221 const callback = form._getOrCreateFieldApi({
222 name: 'parent.callback',
223 validators: [callbackValidator] as never,
224 })
225 const unregisterParent = parent._register()
226 const unregisterMounted = mounted._register()
227​
228 setFieldError(mounted)
229 setFieldError(killed)
230 setFieldError(callback)
231 killed._isKilled = true
232​
233 try {
234 expect(getFieldDebugSuspicions({ field: parent })).toEqual([])
235 } finally {
236 unregisterMounted()
237 unregisterParent()
238 }
239 })
240​
241 it('rejects unmounted fields and fields with errors of their own', () => {
242 const form = new InternalFormApi({
243 defaultValues: { parent: { child: '' }, other: { child: '' } },
244 })
245 const parent = form._getOrCreateFieldApi({
246 name: 'parent',
247 validators: [schemaValidator, emptyTriggerValidator] as never,
248 })
249 const child = form._getOrCreateFieldApi({
250 name: 'parent.child',
251 validators: [schemaValidator] as never,
252 })
253 const other = form._getOrCreateFieldApi({
254 name: 'other',
255 validators: [emptyTriggerValidator] as never,
256 })
257 const otherChild = form._getOrCreateFieldApi({
258 name: 'other.child',
259 validators: [schemaValidator] as never,
260 })
261 const unregisterParent = parent._register()
262​
263 setFieldError(parent)
264 setFieldError(child)
265 setFieldError(otherChild)
266​
267 try {
268 expect(getFieldDebugSuspicions({ field: parent })).toEqual([])
269 expect(getFieldDebugSuspicions({ field: other })).toEqual([])
270 } finally {
271 unregisterParent()
272 }
273 })
274​
275 it('preserves evaluator registry order', () => {
276 const form = new InternalFormApi({ defaultValues: { name: '' } })
277 const field = form._getOrCreateFieldApi({ name: 'name' })
278 const unregister = field._register()
279 const cases: Array<FieldDebugCase> = ['first', 'second'].map(
280 (descendantPath) => ({
281 evaluate: ({ field: target }) => ({
282 kind: 'schema-errors-on-unmounted-descendants',
283 evidence: {
284 fieldPath: target.name,
285 unmountedDescendantPaths: [descendantPath],
286 },
287 }),
288 }),
289 )
290​
291 try {
292 expect(
293 getFieldDebugSuspicions({ field }, cases).map(({ evidence }) =>
294 'unmountedDescendantPaths' in evidence
295 ? evidence.unmountedDescendantPaths[0]
296 : undefined,
297 ),
298 ).toEqual(['first', 'second'])
299 } finally {
300 unregister()
301 }
302 })
303})