Open History to see the last commit
1import { batch } from '@tanstack/store'
2import { createOutput } from './validationOutput.lib'
3import { defaultInternalBaseFieldMeta } from './FieldApi/fieldState.lib'
4import { visitAllFormFields } from './FieldApi/fieldTraversal.lib'
5import { parseStandardSchemaIssues } from './standardSchema.lib'
6import { evaluate } from './utils.lib'
7import { runValidatorPipeline } from './validation'
8import { createErrorMap } from './validation.public'
9import { devtools } from './devtoolsBridge.lib'
10import { reconcileValidatorInstances } from './ValidatorInstance.lib'
11import type { FormOptions } from './FormApi/FormApi.public'
12import type { FormErrorMeta } from './FormApi/formState.lib'
13import type { InternalFormApi } from './FormApi/FormApi.lib'
14import type { AnyInternalFieldApi } from './FieldApi/FieldApi.lib'
15import type {
16 FormValidateResultFromErrorTypes,
17 FormValidators,
18 ToServerFormErrorTypes,
19} from './validation.public'
20import type { ServerFormState, ServerValidateResult } from './ssr.public'
21β
22type ServerFormValidateResult<
23 TFormData,
24 TFormValidators extends FormValidators<TFormData>,
25> = FormValidateResultFromErrorTypes<
26 TFormData,
27 ToServerFormErrorTypes<TFormValidators>
28>
29β
30function createInitialFormErrorMeta(): FormErrorMeta {
31 return {
32 validationSourceErrors: null,
33 }
34}
35β
36function resetFieldMetaForServerState(form: InternalFormApi<any, any, any>) {
37 visitAllFormFields(form._fieldRootNode, (field) => {
38 field._defaultValueCache = null
39β
40 field._listenerInstances?.forEach((instance) => instance.resetRuntime())
41 field._validatorInstances?.forEach((instance) => instance.resetRuntime())
42β
43 const metaAtom = field._atoms.meta
44 if (metaAtom && metaAtom.get() !== defaultInternalBaseFieldMeta) {
45 metaAtom.set(defaultInternalBaseFieldMeta)
46 devtools().updateField?.(field)
47 }
48 })
49}
50β
51function resetToServerState<TFormData>(
52 form: InternalFormApi<TFormData, any, any>,
53 serverState: ServerFormState<TFormData, any>,
54 defaultValues: TFormData,
55): void {
56 const values = serverState.values ?? defaultValues
57 const shouldUpdateDefaultValues = !evaluate(
58 values,
59 form._options.defaultValues,
60 )
61β
62 form._listenerInstances?.forEach((instance) => instance.resetRuntime())
63 form._validatorInstances?.forEach((instance) => instance.resetRuntime())
64 form._onSubmitSource.resetRuntime()
65 form._defaultValueCache = null
66β
67 if (shouldUpdateDefaultValues) {
68 form._options = {
69 ...form._options,
70 defaultValues: values,
71 }
72 }
73β
74 batch(() => {
75 resetFieldMetaForServerState(form)
76 if (shouldUpdateDefaultValues) {
77 form._atoms.defaultValuesVersion.set((version) => version + 1)
78 }
79 form._atoms.values.set(values)
80 form._atoms.meta.isDirty.set(false)
81 form._atoms.meta.touchedFieldCount.set(0)
82 form._atoms.meta.formErrors.set(createInitialFormErrorMeta())
83 form._atoms.meta.errorFields.set(new Set<AnyInternalFieldApi>())
84 form._atoms.meta.fieldValidationCount.set(0)
85 form._atoms.meta.validationCount.set(0)
86 form._atoms.meta.isSubmitting.set(false)
87 form._atoms.meta.isSubmitSuccessful.set(false)
88 form._atoms.meta.submissionAttempts.set(serverState.submissionAttempts)
89β
90 for (const result of serverState.validationResults) {
91 const validatorInstance =
92 form._validatorInstances?.[result.validatorIndex]
93 if (!validatorInstance) continue
94β
95 form._processValidationResult({ ...result, validatorInstance }, 'server')
96 }
97 })
98}
99β
100export function applyServerState<TFormData>(
101 form: InternalFormApi<TFormData, any, any>,
102 serverState: ServerFormState<TFormData, any> | null,
103 defaultValues: TFormData,
104): void {
105 if (serverState === form._lastServerState) return
106β
107 form._lastServerState = serverState
108β
109 if (!serverState) {
110 form._clearFormValidationSource('server')
111 return
112 }
113β
114 resetToServerState(form, serverState, defaultValues)
115}
116β
117export async function validateServerValues<
118 TFormData,
119 const TFormValidators extends FormValidators<TFormData>,
120 TSubmitReturn,
121>(
122 options: FormOptions<TFormData, TFormValidators, TSubmitReturn, unknown>,
123 values: TFormData,
124): Promise<ServerValidateResult<TFormData, TFormValidators>> {
125 const pipeline = options.validators
126β
127 if (!pipeline || pipeline.length === 0) {
128 return {
129 success: true,
130 values,
131 validatorOutputs: [] as never,
132 }
133 }
134β
135 const validatorInstances = reconcileValidatorInstances({
136 definitions: pipeline,
137 instances: null,
138 owner: options,
139 scope: 'form',
140 })
141β
142 try {
143 const pipelineResult = await runValidatorPipeline<
144 ServerFormValidateResult<TFormData, TFormValidators>
145 >({
146 pipeline: validatorInstances ?? [],
147 context: {
148 scope: 'server',
149 event: 'server',
150 formApi: undefined,
151 },
152 hasFailedBefore: false,
153 getContext: (ctx) => ({
154 event: 'server',
155 signal: ctx.signal,
156 formApi: undefined,
157 value: values,
158 createErrorMap,
159 createOutput,
160 parseIssues: (issues) =>
161 parseStandardSchemaIssues(issues, values, 'form'),
162 }),
163 scope: 'form',
164 })
165β
166 if (pipelineResult.thrownError !== null) {
167 throw pipelineResult.thrownError
168 }
169β
170 const validatorOutputs =
171 validatorInstances?.map((instance) => {
172 const result = pipelineResult.results.find(
173 (r) => r.validatorInstance === instance,
174 )
175 return result?.hasOutput ? result.output : undefined
176 }) ?? []
177β
178 const validationResults = pipelineResult.results.map((result) => ({
179 validatorIndex:
180 validatorInstances?.indexOf(result.validatorInstance) ?? -1,
181 result: result.result,
182 output: result.output,
183 hasOutput: result.hasOutput,
184 }))
185β
186 if (pipelineResult.hasErrors) {
187 return {
188 success: false,
189 serverState: {
190 values,
191 validationResults,
192 submissionAttempts: 1,
193 },
194 }
195 }
196β
197 return {
198 success: true,
199 values,
200 validatorOutputs: validatorOutputs as never,
201 }
202 } finally {
203 validatorInstances?.forEach((instance) => instance.dispose())
204 }
205}