import { batch, createAtom } from '@tanstack/store' import { SubmissionAttempt } from './submissionAttempt.lib' import { getBy } from './utils.lib' import { createErrorMap } from './validation/results/createErrorMap.lib' import { parseIssuesFactory } from './validation/results/parseIssues.lib' import { getValidationErrors, isErrorResult, } from './validation/results/errors.lib' import { createValidationError, isSubmitError, submitErrorSymbol, withSubmitError, } from './submissionError.lib' import type { SubmissionInput } from './submissionAttempt.lib' import type { AnyInternalFieldApi, InternalFieldValidatorInstance, } from './FieldApi/FieldApi.lib' import type { InternalFormApi, InternalFormValidatorInstance, } from './FormApi/FormApi.lib' import type { FormSubmitContext, SubmitInvalidContext, } from './FormApi/formSubmit.public' import type { InternalFormGroupApi, InternalGroupValidatorInstance, } from './FormGroupApi/FormGroupApi.lib' import type { DeepKeys, DeepValue } from './deep-keys.public' import type { AnyValidatorInstance } from './pipeline/validation/ValidatorInstance.lib' import type { ClientValidationRun } from './pipeline/validation/clientValidation.lib' import type { FormGroupValidators, ToFormGroupOutputs, } from './pipeline/validation/validation.public' import type { Awaitable } from './types.public' import type { ScopedErrorTypes } from './validation/state.public' import type { FormValidationResult, FormattedValidationError, } from './validation/results/results.public' import type { Atom, ReadonlyAtom } from '@tanstack/store' type SubmissionContext = Omit< FormSubmitContext>, 'formApi' > type FieldRuns = Array< ClientValidationRun | undefined > export interface SubmissionStateAtoms { isSubmitting: ReadonlyAtom isSubmitSuccessful: ReadonlyAtom submissionAttempts: ReadonlyAtom } export type FormSubmissionHandler = SubmissionHandler< TFormData, InternalFormValidatorInstance > export type FormGroupSubmissionHandler = SubmissionHandler< TGroupValue, InternalGroupValidatorInstance > /** * Connects shared submission handling to form or group validation, callbacks, * and error state. */ interface SubmissionHandlerAdapter< TValue, TInstance extends AnyValidatorInstance, > { capture: () => SubmissionInput /** Updates owner-specific state in the same batch as attempt registration. */ onStart?: () => void /** Notifies submit listeners before field submit events and validation. */ notifySubmit?: () => void /** * Starts form or group submit validation after field validation. * `hasFailed` indicates whether field validation produced errors. */ runValidation: ( submission: SubmissionAttempt>, hasFailed: boolean, ) => ClientValidationRun | undefined /** * Invokes the configured `onSubmit` callback of the form or form group. * * You do not need to parse the result, simply forward it. */ onSubmit: (context: SubmissionContext) => unknown /** * Invokes the form or group's `onSubmitInvalid` callback. * * The returned promise is awaited to settle or rethrow. */ onSubmitInvalid: ( context: SubmitInvalidContext & { value: TValue }, ) => Awaitable /** * Applies the submit error to form or group state, or clears prior submit * errors for `null`. * Called only while the attempt can still apply validation results. */ applySubmitError: (error: FormValidationResult) => void } interface SubmissionValidation { hasFailed: boolean errors: Array> validatorOutputs: Array exception?: { error: unknown } } interface SubmissionOutcome { /** Errors returned to the caller when the attempt completes. */ errors: Array /** Whether submission succeeded; an empty `errors` array can still mean failure. */ successful: boolean } class SubmissionHandler { private readonly submissions = new Set< SubmissionAttempt> >() private readonly adapter: SubmissionHandlerAdapter private readonly isSubmitting: Atom private readonly isSubmitSuccessful: Atom private readonly submissionAttempts: Atom readonly atoms: SubmissionStateAtoms private readonly finishSubmission: ( submission: SubmissionAttempt>, successful: boolean, ) => void constructor( adapter: SubmissionHandlerAdapter, initialSubmissionAttempts = 0, ) { this.adapter = adapter this.submissionAttempts = createAtom(initialSubmissionAttempts) this.isSubmitSuccessful = createAtom(false) this.isSubmitting = createAtom(false) this.atoms = { isSubmitting: this.isSubmitting, isSubmitSuccessful: this.isSubmitSuccessful, submissionAttempts: this.submissionAttempts, } this.finishSubmission = (submission, successful) => { if (!this.submissions.delete(submission)) return batch(() => { this.isSubmitting.set(this.submissions.size > 0) this.isSubmitSuccessful.set(successful) }) } } handleSubmit() { const submission = new SubmissionAttempt>( this.adapter.capture(), this.finishSubmission, ) void this.runSubmission(submission).catch((error) => submission.fail(error)) return submission.promise } private async runSubmission( submission: SubmissionAttempt>, ): Promise { this.submissions.add(submission) batch(() => { this.submissionAttempts.set((attempts) => attempts + 1) this.isSubmitting.set(true) this.adapter.onStart?.() }) if (!submission.isActive()) return const validation = await this.validateSubmission(submission) if (!submission.beginCallbacks()) return const outcome = await this.runSubmissionCallbacks(submission, validation) submission.complete(outcome.errors, outcome.successful) } private async validateSubmission( submission: SubmissionAttempt>, ): Promise> { const validation: SubmissionValidation = { hasFailed: false, errors: [], validatorOutputs: [], } this.adapter.notifySubmit?.() if (!submission.isActive()) return validation for (const field of submission.notificationFields) { if (!submission.isActive()) return validation if (field._isKilled) continue field._notifyListener({ trigger: 'submit', seenFields: new WeakSet() }) } try { const fieldRuns: FieldRuns = [] const fieldOutcomes = await Promise.allSettled( Array.from(submission.fields.keys(), async (field, index) => { if (!submission.isActive()) return const run = field._runFieldValidation('submit', { catchErrors: false, onResult: false, submission, }) fieldRuns[index] = run await run?.pending }), ) if (!submission.isActive()) return validation batch(() => { let fieldIndex = 0 for (const [field, snapshot] of submission.fields) { // Remember, fieldRuns.length === submission.fields.size const run = fieldRuns[fieldIndex] fieldIndex++ if (!run) continue for (const result of run.collector.getResults()) { if (!submission.canApplyValidationResults()) return if (isErrorResult(result.value.result)) { validation.hasFailed = true validation.errors.push( ...getValidationErrors(result.value.result), ) } // A value changed during the submission, which would've cleared the error. if (Object.is(field.value, snapshot.value)) { field._processValidationResult(result, 'submit') } } } }) if (!submission.isActive()) return validation for (const outcome of fieldOutcomes) { if (outcome.status === 'rejected') throw outcome.reason } const run = this.adapter.runValidation(submission, validation.hasFailed) await run?.pending if (!submission.isActive() || !run) return validation validation.hasFailed ||= run.collector.hasErrors() validation.errors = run.collector .getResults() .flatMap(({ value }) => getValidationErrors(value.result)) .concat(validation.errors) if (!validation.hasFailed) { validation.validatorOutputs = run.collector.getOutputs( run.validatorCount, ) } return validation } catch (error) { validation.exception = { error } return validation } } private async runSubmissionCallbacks( submission: SubmissionAttempt>, validation: SubmissionValidation, ): Promise>> { const earlyExit = { errors: [], successful: false } const finishInvalidSubmission = async ( failure: Omit, ) => { const state = { shouldThrow: failure.reason === 'exception' } await this.adapter.onSubmitInvalid({ ...failure, value: submission.value, preventThrow: () => { state.shouldThrow = false }, }) if (state.shouldThrow) throw failure.error return { errors: validation.errors, successful: false } } if (validation.exception) { return await finishInvalidSubmission({ reason: 'exception', source: 'validators', error: validation.exception.error, }) } if (validation.hasFailed) { return await finishInvalidSubmission({ reason: 'validation', source: 'validators', error: undefined, }) } let submitError: FormValidationResult = null try { const maybeError = await this.adapter.onSubmit({ value: submission.value, validatorOutputs: validation.validatorOutputs, createValidationError, createErrorMap: withSubmitError(createErrorMap), parseIssues: withSubmitError( parseIssuesFactory(submission.value, 'field'), ), }) submitError = isSubmitError(maybeError) ? maybeError[submitErrorSymbol] : null if (submission.canApplyValidationResults()) { this.adapter.applySubmitError(submitError) } } catch (error) { return await finishInvalidSubmission({ reason: 'exception', source: 'onSubmit', error, }) } if (isErrorResult(submitError)) { validation.hasFailed = true validation.errors.push(...getValidationErrors(submitError)) } if (validation.hasFailed) { return await finishInvalidSubmission({ reason: 'validation', source: 'onSubmit', error: undefined, }) } return { errors: validation.errors, successful: true } } /** Detaches pending attempts and clears flags, preserving the attempt count. */ invalidate(): void { batch(() => { const submissions = Array.from(this.submissions) this.submissions.clear() for (const submission of submissions) submission.invalidate() this.isSubmitting.set(false) this.isSubmitSuccessful.set(false) }) } setSubmissionAttempts(attempts: number): void { this.submissionAttempts.set(attempts) } } export function createFormSubmissionHandler( form: InternalFormApi, initialSubmissionAttempts: number, ): FormSubmissionHandler { return new SubmissionHandler( { capture: () => { const values = form._atoms.values.get() return { values, value: values, node: form._fieldRootNode, validators: form._validatorInstances, } }, notifySubmit: () => form._notifyFormListener('submit', null), runValidation: (submission, hasFailed) => form._runFormValidation('submit', { catchErrors: false, hasFailedBefore: hasFailed, submission, }), onSubmit: (context) => form._options.onSubmit?.({ ...context, formApi: form as never }), onSubmitInvalid: (context) => form._options.onSubmitInvalid?.({ ...context, formApi: form }), applySubmitError: (error) => form._applyValidationResult(form._onSubmitSource, error, 'submit'), }, initialSubmissionAttempts, ) } export function createGroupSubmissionHandler< TFormData, TGroupName extends DeepKeys, TGroupValue extends DeepValue, TGroupValidators extends FormGroupValidators, TFormError extends ScopedErrorTypes, TSubmitReturn, >( group: InternalFormGroupApi< TFormData, TGroupName, TGroupValue, TGroupValidators, TFormError, TSubmitReturn >, ): FormGroupSubmissionHandler { return new SubmissionHandler({ capture: () => { const values = group.form.state.values return { values, value: getBy(values, group.name), node: group._groupField, validators: group._validatorInstances, } }, onStart: () => group._groupField._setMeta((meta) => meta.isTouched ? meta : { ...meta, isTouched: true }, ), runValidation: (submission, hasFailed) => group._runGroupValidation('submit', { catchErrors: false, upstreamInvalid: hasFailed, submission, }), onSubmit: (context) => group._options.onSubmit?.({ ...context, validatorOutputs: context.validatorOutputs as ToFormGroupOutputs, formApi: group.form, groupApi: group as never, }), onSubmitInvalid: (context) => group._options.onSubmitInvalid?.({ ...context, formApi: group.form, groupApi: group as never, }), applySubmitError: (error) => group._applyValidationResult(group._onSubmitSource, error, 'submit'), }) }