Open History to see the last commit
1import { describe, expectTypeOf, it } from 'vitest'
2import { z } from 'zod'
3import { validateServerValues } from '../src/internals'
4import { formOptions, serverValidateHelper } from '../src'
5import type {
6 FieldValidators,
7 FormApi,
8 FormGroupValidators,
9 FormOptions,
10 FormValidators,
11 ParsedStandardSchemaIssues,
12 ServerFormState,
13 ServerValidateFrameworkPlugin,
14} from '../src'
15β
16describe('server validation types', () => {
17 it('accepts server validators and preserves schema output inference', async () => {
18 const options = formOptions({
19 defaultValues: { name: '' },
20 validators: [
21 {
22 run: z
23 .object({
24 name: z.string(),
25 })
26 .transform(({ name }) => ({ nameLength: name.length })),
27 triggers: ['server'],
28 },
29 ],
30 })
31β
32 const result = await validateServerValues(options, { name: 'Tony' })
33β
34 if (!result.success) {
35 throw new Error('Expected server validation to succeed')
36 }
37β
38 expectTypeOf(result.values).toEqualTypeOf<{ name: string }>()
39 expectTypeOf(result.validatorOutputs).toEqualTypeOf<
40 readonly [{ nameLength: number }]
41 >()
42β
43 type Values = { name: string }
44 type Validators = NonNullable<typeof options.validators>
45β
46 type ValidationResult = ServerFormState<
47 Values,
48 Validators
49 >['validationResults'][number]['result']
50β
51 expectTypeOf<null | ParsedStandardSchemaIssues<Values>>().toExtend<ValidationResult>()
52 })
53β
54 it('preserves validator generics on failed server validation results', async () => {
55 const options = formOptions({
56 defaultValues: { name: '' },
57 validators: [
58 {
59 run: () => ({
60 fields: {
61 name: 'Name is required',
62 },
63 }),
64 triggers: ['server'],
65 },
66 ],
67 })
68β
69 const result = await validateServerValues(options, { name: '' })
70β
71 if (result.success) {
72 throw new Error('Expected server validation to fail')
73 }
74β
75 type Values = { name: string }
76 type Validators = NonNullable<typeof options.validators>
77β
78 expectTypeOf(result.serverState).toEqualTypeOf<
79 ServerFormState<Values, Validators>
80 >()
81 type Result =
82 (typeof result.serverState.validationResults)[number]['result']
83β
84 expectTypeOf<{
85 fields: {
86 name: 'Name is required'
87 }
88 }>().toExtend<Result>()
89 })
90β
91 it('bases server state compatibility on server result types', () => {
92 type Values = { name: string }
93 interface BaseIssue {
94 message: string
95 }
96 interface DetailedIssue extends BaseIssue {
97 code: number
98 }
99 interface IncompatibleIssue extends BaseIssue {
100 reason: string
101 }
102β
103 const detailedOptions = formOptions({
104 defaultValues: { name: '' },
105 validators: [
106 {
107 run: (): DetailedIssue => ({ message: 'Invalid name', code: 400 }),
108 triggers: ['server'],
109 },
110 ],
111 })
112 const baseOptions = formOptions({
113 defaultValues: { name: '' },
114 validators: [
115 {
116 run: (): BaseIssue => ({ message: 'Invalid name' }),
117 triggers: ['server'],
118 },
119 ],
120 })
121 const incompatibleOptions = formOptions({
122 defaultValues: { name: '' },
123 validators: [
124 {
125 run: (): IncompatibleIssue => ({
126 message: 'Invalid name',
127 reason: 'missing',
128 }),
129 triggers: ['server'],
130 },
131 ],
132 })
133β
134 type DetailedState = ServerFormState<
135 Values,
136 NonNullable<typeof detailedOptions.validators>
137 >
138 const detailedState = null as never as DetailedState
139β
140 formOptions({
141 ...baseOptions,
142 serverState: detailedState,
143 })
144β
145 formOptions({
146 ...incompatibleOptions,
147 // @ts-expect-error The serialized server error is incompatible.
148 serverState: detailedState,
149 })
150 })
151β
152 it('ignores schema outputs and client-only errors for state compatibility', () => {
153 type Values = { name: string }
154β
155 const lengthOptions = formOptions({
156 defaultValues: { name: '' },
157 validators: [
158 {
159 run: z
160 .object({ name: z.string() })
161 .transform(({ name }) => name.length),
162 triggers: ['server'],
163 },
164 {
165 run: () => ({ message: 'Client A', clientA: true }),
166 triggers: ['change'],
167 },
168 ],
169 })
170 const uppercaseOptions = formOptions({
171 defaultValues: { name: '' },
172 validators: [
173 {
174 run: z
175 .object({ name: z.string() })
176 .transform(({ name }) => name.toUpperCase()),
177 triggers: ['server'],
178 },
179 {
180 run: () => ({ message: 'Client B', clientB: true }),
181 triggers: ['blur'],
182 },
183 ],
184 })
185β
186 type LengthState = ServerFormState<
187 Values,
188 NonNullable<typeof lengthOptions.validators>
189 >
190 type UppercaseState = ServerFormState<
191 Values,
192 NonNullable<typeof uppercaseOptions.validators>
193 >
194β
195 expectTypeOf<LengthState>().toEqualTypeOf<UppercaseState>()
196 })
197β
198 it('makes formApi optional for validators with server triggers', () => {
199 formOptions({
200 defaultValues: { name: '' },
201 validators: [
202 {
203 run: (ctx) => {
204 expectTypeOf(ctx.event).toEqualTypeOf<
205 'change' | 'blur' | 'submit' | 'server'
206 >()
207 expectTypeOf(ctx.value).toEqualTypeOf<{ name: string }>()
208 expectTypeOf(ctx.formApi).toEqualTypeOf<
209 FormApi<{ name: string }, any> | undefined
210 >()
211 // @ts-expect-error formApi can be undefined for server-triggered validators.
212 void ctx.formApi.state.values
213 return undefined
214 },
215 triggers: ['server'],
216 },
217 {
218 run: ({ formApi }) => {
219 expectTypeOf(formApi).toEqualTypeOf<
220 FormApi<{ name: string }, any> | undefined
221 >()
222 return undefined
223 },
224 triggers: ['server', 'change'],
225 },
226 {
227 run: ({ formApi }) => {
228 expectTypeOf(formApi).toEqualTypeOf<
229 FormApi<{ name: string }, any> | undefined
230 >()
231 return undefined
232 },
233 triggers: [],
234 },
235 {
236 run: ({ formApi }) => {
237 expectTypeOf(formApi).toEqualTypeOf<
238 FormApi<{ name: string }, any> | undefined
239 >()
240 return undefined
241 },
242 skipOnSubmit: ({ formApi }) => {
243 expectTypeOf(formApi.state.values).toEqualTypeOf<{
244 name: string
245 }>()
246 return false
247 },
248 triggerDebounceMs: ({ formApi }) => {
249 expectTypeOf(formApi.state.values).toEqualTypeOf<{
250 name: string
251 }>()
252 return 0
253 },
254 triggers: [],
255 },
256 {
257 run: () => {
258 return undefined
259 },
260 triggers: [],
261 },
262 ],
263 })
264 })
265β
266 it('rejects server trigger configs and non-form server validators', () => {
267 formOptions({
268 defaultValues: { name: '' },
269 validators: [
270 {
271 run: () => undefined,
272 triggers: [
273 {
274 // @ts-expect-error Server triggers cannot be configured.
275 trigger: 'server',
276 },
277 ],
278 },
279 {
280 run: () => undefined,
281 triggers: [],
282 // @ts-expect-error Server validation is configured with triggers.
283 runOnServer: true,
284 },
285 ],
286 })
287β
288 const fieldValidators: FieldValidators<{ name: string }, 'name', string> = [
289 {
290 run: () => undefined,
291 triggers: [
292 // @ts-expect-error Field validators cannot use server triggers.
293 'server',
294 ],
295 },
296 ]
297 const groupValidators: FormGroupValidators<{ name: string }> = [
298 {
299 run: () => undefined,
300 triggers: [
301 // @ts-expect-error Form group validators cannot use server triggers.
302 'server',
303 ],
304 },
305 ]
306β
307 void fieldValidators
308 void groupValidators
309 })
310β
311 it('preserves plugin-customized validator return signatures', () => {
312 const plugin = {
313 id: 'react-form-test',
314 createServerValidate: <
315 TFormData,
316 const TFormValidators extends FormValidators<TFormData>,
317 TSubmitReturn,
318 >(
319 _options: FormOptions<
320 TFormData,
321 TFormValidators,
322 TSubmitReturn,
323 unknown
324 >,
325 ) => {
326 return (values: TFormData) => Promise.resolve(values)
327 },
328 } satisfies ServerValidateFrameworkPlugin
329β
330 const { createServerValidate } = serverValidateHelper({ framework: plugin })
331 const validate = createServerValidate(
332 formOptions({
333 defaultValues: { name: '' },
334 validators: [
335 {
336 run: () => undefined,
337 triggers: ['server'],
338 },
339 ],
340 }),
341 )
342β
343 expectTypeOf(validate).parameter(0).toEqualTypeOf<{ name: string }>()
344 })
345β
346 it('preserves plugin-customized validator options and form-bound helpers', () => {
347 const plugin = {
348 id: 'react-form-test',
349 createServerValidate: <
350 TFormData,
351 const TFormValidators extends FormValidators<TFormData>,
352 TSubmitReturn,
353 >(
354 _options: FormOptions<
355 TFormData,
356 TFormValidators,
357 TSubmitReturn,
358 unknown
359 >,
360 _pluginOptions?: { field: keyof TFormData },
361 ) => {
362 return Object.assign((values: TFormData) => Promise.resolve(values), {
363 getState: () =>
364 Promise.resolve(
365 null as never as ServerFormState<TFormData, TFormValidators>,
366 ),
367 })
368 },
369 } satisfies ServerValidateFrameworkPlugin
370β
371 const options = formOptions({
372 defaultValues: { name: '', age: 0 },
373 validators: [
374 {
375 run: () => undefined,
376 triggers: ['server'],
377 },
378 ],
379 })
380β
381 const { createServerValidate } = serverValidateHelper({ framework: plugin })
382 const validate = createServerValidate(options, { field: 'age' })
383β
384 // @ts-expect-error Plugin options are typed against the form values.
385 createServerValidate(options, { field: 'missing' })
386β
387 expectTypeOf(validate).parameter(0).toEqualTypeOf<{
388 name: string
389 age: number
390 }>()
391 expectTypeOf(validate.getState()).toEqualTypeOf<
392 Promise<
393 ServerFormState<
394 { name: string; age: number },
395 NonNullable<typeof options.validators>
396 >
397 >
398 >()
399 })
400})