Validation tests passing.

Author: ciscoheat

src/lib/client/index.ts

@@ -892,27 +892,28 @@ async function validateField<T extends AnyZodObject, M>(
   }
 
   let value = options.value;
+  let shouldUpdate = true;
   const currentData = get(data);
 
   if (!('value' in options)) {
+    // Use value from data
     const dataToValidate = traversePath(
       currentData,
       path as FieldPath<typeof currentData>
     );
 
-    if (!dataToValidate) {
-      throw new SuperFormError('Validation data not found: ' + path);
-    }
-
-    value = dataToValidate.value;
+    value = dataToValidate?.value;
   } else if (options.update === true || options.update === 'value') {
+    // Value should be updating the data
     data.update(
       ($data) => {
         setPaths($data, [path], value);
         return $data;
       },
       { taint: options.taint }
     );
+  } else {
+    shouldUpdate = false;
   }
 
   //console.log('🚀 ~ file: index.ts:871 ~ validate:', path, value);
@@ -951,7 +952,7 @@ async function validateField<T extends AnyZodObject, M>(
   if ('safeParseAsync' in validators) {
     // Zod validator
     // Check if any effects exist for the path, then parse the entire schema.
-    const leaf = traversePath(
+    const noEffects = traversePath(
       validators,
       validationPath as FieldPath<typeof validators>,
       (pathData) => {
@@ -962,10 +963,10 @@ async function validateField<T extends AnyZodObject, M>(
       }
     );
 
-    if (leaf) {
+    if (noEffects) {
       const validator = extractValidator(
-        unwrapZodType(leaf.parent),
-        leaf.key
+        unwrapZodType(noEffects.parent),
+        noEffects.key
       );
       if (validator) {
         //console.log('🚀 ~ file: index.ts:972 ~ no effects:', validator);
@@ -982,14 +983,22 @@ async function validateField<T extends AnyZodObject, M>(
     //console.log('🚀 ~ file: index.ts:983 ~ Effects found, validating all');
 
     // Effects are found, validate entire data, unfortunately
+    let dataToValidate = currentData;
+
+    if (!shouldUpdate) {
+      // If value shouldn't update, clone and set the new value
+      dataToValidate = clone(currentData);
+      setPaths(dataToValidate, [path], value);
+    }
+
     const result = await (validators as ZodTypeAny).safeParseAsync(
-      get(data)
+      dataToValidate
     );
 
     if (!result.success) {
       const errors = result.error.format();
       const current = traversePath(errors, path as FieldPath<typeof errors>);
-      return setError(current?.value?._errors);
+      return setError(options.errors ?? current?.value?._errors);
     } else {
       return setError(undefined);
     }

src/routes/+layout.svelte

@@ -38,7 +38,8 @@
   <br />
   <a href="/files">Files</a> |
   <a href="/spa">SPA</a> |
-  <a href="/nested-validation">Client-side validation</a>
+  <a href="/nested-validation">Client-side validation</a> |
+  <a href="/tests/rex">Side-effect validation</a>
 </nav>
 
 <slot />

src/routes/tests/rex/+page.server.ts

@@ -1,19 +1,24 @@
 import { fail } from '@sveltejs/kit';
 import type { Actions, PageServerLoad } from './$types';
-import { basicSchema, subRefined, refined } from './schema';
+import { basicSchema, refined } from './schema';
 import { message, superValidate } from '$lib/server';
 
-export const load = (async () => {
+export const load = (async ({ url }) => {
   // Server API:
-  const form = await superValidate(subRefined);
+  const form = await superValidate(
+    url.searchParams.has('refined') ? refined : basicSchema
+  );
 
   // Always return { form } in load and form actions.
   return { form };
 }) satisfies PageServerLoad;
 
 export const actions: Actions = {
-  default: async ({ request }) => {
-    const form = await superValidate(request, subRefined);
+  default: async ({ request, url }) => {
+    const form = await superValidate(
+      request,
+      url.searchParams.has('refined') ? refined : basicSchema
+    );
     console.log('POST', form);
 
     // Convenient validation check:

src/routes/tests/rex/+page.svelte

@@ -1,24 +1,31 @@
 <script lang="ts">
   import type { PageData } from './$types';
   import { superForm } from '$lib/client';
-  import { basicSchema, subRefined, refined } from './schema';
+  import { basicSchema, refined } from './schema';
   import { page } from '$app/stores';
 
   export let data: PageData;
 
+  const validators = $page.url.searchParams.has('refined')
+    ? refined
+    : basicSchema;
+
   // Client API:
   const { form, errors, constraints, message, enhance } = superForm(
     data.form,
     {
       dataType: 'json',
-      validators: subRefined,
+      validators: validators,
       validationMethod: ($page.url.searchParams.get('method') ??
         undefined) as any
     }
   );
 </script>
 
 <h4>Validation method: {$page.url.searchParams.get('method') ?? 'auto'}</h4>
+<h4>
+  Schema: {$page.url.searchParams.has('refined') ? 'refined' : 'simple'}
+</h4>
 
 <form method="POST" use:enhance>
   {#if $message}
@@ -45,7 +52,7 @@
   <!-- {...$constraints.email} -->
   {#if $errors.email}<span class="invalid">{$errors.email}</span>{/if}
 
-  <div>
+  <div class="tags">
     {#each $form.tags as _, i}
       <div>
         <label for="min">Min</label>

src/routes/tests/rex/schema.ts

@@ -15,40 +15,39 @@ export const basicSchema = z.object({
     .default([{ min: 5, max: 10 }])
 });
 
-export const subRefined = z.object({
-  name: z.string().min(4).default('Hello world!'),
-  email: z.string().email(),
-  items: z.optional(
-    z.array(z.object({ title: z.string(), name: z.string().min(3) }))
-  ),
-  tags: z
-    .object({
-      min: z.number().int().min(5),
-      max: z.number().int().min(5)
-    })
-    .refine(
-      (data) => {
-        if (data.min && data.max) {
-          return data.min <= data.max;
+export const refined = z
+  .object({
+    name: z.string().min(4).default('Hello world!'),
+    email: z.string().email(),
+    items: z.optional(
+      z.array(z.object({ title: z.string(), name: z.string().min(3) }))
+    ),
+    tags: z
+      .object({
+        min: z.number().int().min(5),
+        max: z.number().int().min(5)
+      })
+      .refine(
+        (data) => {
+          if (data.min && data.max) {
+            return data.min <= data.max;
+          }
+          return true;
+        },
+        {
+          path: ['max'],
+          message: 'Max must be greater or equal to min'
         }
-        return true;
-      },
-      {
-        path: ['max'],
-        message: 'Max must be greater or equal to min'
-      }
-    )
-    .array()
-    .default([{ min: 5, max: 10 }])
-});
-
-export const refined = basicSchema
-  .refine(({ name }) => name === 'bob', {
-    message: 'Oof, name is non bob',
+      )
+      .array()
+      .default([{ min: 5, max: 10 }])
+  })
+  .refine(({ name }) => name !== 'nope', {
+    message: 'Nope',
     path: ['name']
   })
-  .refine(({ name }) => name === 'john', {
-    message: 'Oof, name is not john',
+  .refine(({ name }) => name !== 'nope', {
+    message: 'Nope',
     path: ['name']
   })
   .superRefine((data, ctx) => {