Tests for array and object errors.

ciscoheat · ciscoheat · commit 519b4eccba7e · 2023-06-05T22:12:10.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -15,6 +15,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+- As with effects, array and object errors now forces the whole Zod schema to be validated client-side.
 - The `Validation` type is now called `SuperValidated`.
 - `StringPath` and `StringPathLeaves` are renamed to `FormPath` and `FormPathLeaves`.
 
@@ -29,6 +30,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- Errors can now be added to arrays and objects in the schema.
 - Added a `posted` store, a boolean which is false if the form hasn't been posted during its current lifetime.
 - `reset` now has an additional `data` option that can be used to re-populate the form with data, and `id` to set a different form id.
 - `intProxy`, `numberProxy`, `dateProxy` and `stringProxy` now have an `empty` option, so empty values can be set to `null` or `undefined`.
diff --git a/src/lib/client/index.ts b/src/lib/client/index.ts
@@ -35,7 +35,11 @@ import {
   type FormPath,
   type FormPathLeaves
 } from '../stringPath.js';
-import { validateField, type Validate } from './validateField.js';
+import {
+  validateField,
+  type Validate,
+  validateObjectErrors
+} from './validateField.js';
 import {
   formEnhance,
   shouldSyncFlash,
@@ -596,7 +600,7 @@ export function superForm<
       options.validationMethod == 'onblur' ||
       options.validationMethod == 'submit-only'
     ) {
-      return;
+      return false;
     }
 
     let shouldValidate = options.validationMethod === 'oninput';
@@ -630,39 +634,43 @@ export function superForm<
 
     if (shouldValidate) {
       await validateField(path, options, Form, Errors, Tainted, { taint });
+      return true;
+    } else {
+      return false;
     }
   }
 
-  function Tainted_update(
+  async function Tainted_update(
     newObj: unknown,
     compareAgainst: unknown,
-    options: TaintOption
+    taintOptions: TaintOption
   ) {
-    if (options === false) {
+    if (taintOptions === false) {
       return;
-    } else if (options === 'untaint-all') {
+    } else if (taintOptions === 'untaint-all') {
       Tainted.set(undefined);
       return;
     }
 
     const paths = comparePaths(newObj, compareAgainst);
 
-    if (options === true) {
+    if (taintOptions === true) {
       LastChanges.set(paths);
     }
 
     if (paths.length) {
       Tainted.update((tainted) => {
         //console.log('Update tainted:', paths, newObj, compareAgainst);
         if (!tainted) tainted = {};
-        setPaths(tainted, paths, options === true ? true : undefined);
+        setPaths(tainted, paths, taintOptions === true ? true : undefined);
         return tainted;
       });
 
+      let updated = false;
       for (const path of paths) {
-        //console.log('🚀 ~ file: index.ts:681 ~ path:', path);
-        Tainted__validate(path, options);
+        updated = updated || (await Tainted__validate(path, taintOptions));
       }
+      if (!updated) await validateObjectErrors(options, get(Form), Errors);
     }
   }
 
diff --git a/src/lib/client/validateField.ts b/src/lib/client/validateField.ts
@@ -1,11 +1,10 @@
-import type { z, AnyZodObject, ZodTypeAny, ZodArray, ZodError } from 'zod';
+import type { z, AnyZodObject, ZodTypeAny, ZodError } from 'zod';
 import { get } from 'svelte/store';
 import type { FormOptions, SuperForm, TaintOption } from './index.js';
 import {
   SuperFormError,
   type FieldPath,
   type TaintedFields,
-  type ValidationErrors,
   type UnwrapEffects,
   type Validators
 } from '../index.js';
@@ -15,8 +14,6 @@ import {
   traversePath,
   traversePaths
 } from '../traversal.js';
-import { hasEffects, type ZodTypeInfo } from '../schemaEntity.js';
-import { unwrapZodType } from '../schemaEntity.js';
 import type { FormPathLeaves } from '../stringPath.js';
 import { clearErrors, clone } from '../utils.js';
 import { errorShape, mapErrors } from '../errors.js';
@@ -36,7 +33,63 @@ export type Validate<
   opts?: ValidateOptions<unknown>
 ) => Promise<string[] | undefined>;
 
-const effectMapCache = new WeakMap<object, boolean>();
+export async function validateObjectErrors<T extends AnyZodObject, M>(
+  formOptions: FormOptions<T, M>,
+  data: z.infer<T>,
+  Errors: SuperForm<T, M>['errors']
+) {
+  if (
+    typeof formOptions.validators !== 'object' ||
+    !('safeParseAsync' in formOptions.validators)
+  ) {
+    return;
+  }
+
+  const validators = formOptions.validators as AnyZodObject;
+  const result = await validators.safeParseAsync(data);
+
+  if (!result.success) {
+    const newErrors = mapErrors(
+      result.error.format(),
+      errorShape(validators as AnyZodObject)
+    );
+
+    Errors.update((currentErrors) => {
+      // Clear current object-level errors
+      traversePaths(currentErrors, (pathData) => {
+        if (pathData.key == '_errors') {
+          return pathData.set(undefined);
+        }
+      });
+
+      // Add new object-level errors and tainted field errors
+      traversePaths(newErrors, (pathData) => {
+        if (pathData.key == '_errors') {
+          return setPaths(currentErrors, [pathData.path], pathData.value);
+        }
+        /*
+            if (!Array.isArray(pathData.value)) return;
+            if (Tainted_isPathTainted(pathData.path, taintedFields)) {
+              setPaths(currentErrors, [pathData.path], pathData.value);
+            }
+            return 'skip';
+            */
+      });
+
+      return currentErrors;
+    });
+  } else {
+    Errors.update((currentErrors) => {
+      // Clear current object-level errors
+      traversePaths(currentErrors, (pathData) => {
+        if (pathData.key == '_errors') {
+          return pathData.set(undefined);
+        }
+      });
+      return currentErrors;
+    });
+  }
+}
 
 // @DCI-context
 export async function validateField<T extends AnyZodObject, M>(
@@ -139,30 +192,6 @@ async function _validateField<T extends AnyZodObject, M>(
     return { validated: false, errors: undefined } as const;
   }
 
-  function extractValidator(
-    data: ZodTypeInfo,
-    key: string
-  ): ZodTypeAny | undefined {
-    if (data.effects) return undefined;
-
-    // No effects, check if ZodObject or ZodArray, which are the
-    // "allowed" objects in the path above the leaf.
-    const type = data.zodType;
-
-    if (type._def.typeName == 'ZodObject') {
-      const nextType = (type as AnyZodObject)._def.shape()[key];
-      const unwrapped = unwrapZodType(nextType);
-      return unwrapped.effects ? undefined : unwrapped.zodType;
-    } else if (type._def.typeName == 'ZodArray') {
-      const array = type as ZodArray<ZodTypeAny>;
-      const unwrapped = unwrapZodType(array.element);
-      if (unwrapped.effects) return undefined;
-      return extractValidator(unwrapped, key);
-    } else {
-      throw new SuperFormError('Invalid validator');
-    }
-  }
-
   ///// Roles ///////////////////////////////////////////////////////
 
   function Tainted_isPathTainted(
@@ -175,12 +204,8 @@ async function _validateField<T extends AnyZodObject, M>(
     return leaf.value === true;
   }
 
-  function Errors_get() {
-    return get(Errors);
-  }
-
-  function Errors_set(newErrors: ValidationErrors<UnwrapEffects<T>>) {
-    Errors.set(newErrors);
+  function Errors_update(updater: Parameters<typeof Errors.update>[0]) {
+    Errors.update(updater);
   }
 
   function Errors_clearFormLevelErrors() {
@@ -230,63 +255,6 @@ 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.
-    if (!effectMapCache.has(validators)) {
-      effectMapCache.set(validators, hasEffects(validators as ZodTypeAny));
-    }
-
-    const effects = effectMapCache.get(validators);
-
-    const perFieldValidator = effects
-      ? undefined
-      : traversePath(
-          validators,
-          Context.validationPath as FieldPath<typeof validators>,
-          (pathData) => {
-            return extractValidator(
-              unwrapZodType(pathData.parent),
-              pathData.key
-            );
-          }
-        );
-
-    if (perFieldValidator) {
-      const validator = extractValidator(
-        unwrapZodType(perFieldValidator.parent),
-        perFieldValidator.key
-      );
-      if (validator) {
-        // Check if validator is ZodArray and the path is an array access
-        // in that case validate the whole array.
-        if (
-          Context.currentData &&
-          validator._def.typeName == 'ZodArray' &&
-          !isNaN(parseInt(path[path.length - 1]))
-        ) {
-          const validateArray = traversePath(
-            Context.currentData,
-            path.slice(0, -1) as FieldPath<typeof Context.currentData>
-          );
-          Context.value = validateArray?.value;
-        }
-
-        //console.log('🚀 ~ file: index.ts:972 ~ no effects:', validator);
-        const result = await validator.safeParseAsync(Context.value);
-        if (!result.success) {
-          const errors = result.error.format();
-          return {
-            validated: true,
-            errors: errors._errors
-          };
-        } else {
-          return { validated: true, errors: undefined };
-        }
-      }
-    }
-
-    //console.log('🚀 ~ file: index.ts:983 ~ Effects found, validating all');
-
-    // Effects are found, validate entire data, unfortunately
     if (!Context.shouldUpdate) {
       // If value shouldn't update, clone and set the new value
       Context.currentData = clone(Context.currentData ?? get(data));
@@ -298,7 +266,6 @@ async function _validateField<T extends AnyZodObject, M>(
     );
 
     if (!result.success) {
-      let currentErrors: ValidationErrors<UnwrapEffects<T>> = {};
       const newErrors = Errors_fromZod(
         result.error,
         validators as AnyZodObject
@@ -307,28 +274,33 @@ async function _validateField<T extends AnyZodObject, M>(
       if (options.update === true || options.update == 'errors') {
         // Set errors for other (tainted) fields, that may have been changed
         const taintedFields = get(Tainted);
-        currentErrors = Errors_get();
-
-        // Special check for form level errors
-        if (currentErrors._errors !== newErrors._errors) {
-          if (
-            !currentErrors._errors ||
-            !newErrors._errors ||
-            currentErrors._errors.join('') != newErrors._errors.join('')
-          ) {
-            currentErrors._errors = newErrors._errors;
-          }
-        }
 
-        traversePaths(newErrors, (pathData) => {
-          if (!Array.isArray(pathData.value)) return;
-          if (Tainted_isPathTainted(pathData.path, taintedFields)) {
-            setPaths(currentErrors, [pathData.path], pathData.value);
-          }
-          return 'skip';
-        });
+        Errors_update((currentErrors) => {
+          // Clear current object-level errors
+          traversePaths(currentErrors, (pathData) => {
+            if (pathData.key == '_errors') {
+              return pathData.set(undefined);
+            }
+          });
+
+          // Add new object-level errors and tainted field errors
+          traversePaths(newErrors, (pathData) => {
+            if (pathData.key == '_errors') {
+              return setPaths(
+                currentErrors,
+                [pathData.path],
+                pathData.value
+              );
+            }
+            if (!Array.isArray(pathData.value)) return;
+            if (Tainted_isPathTainted(pathData.path, taintedFields)) {
+              setPaths(currentErrors, [pathData.path], pathData.value);
+            }
+            return 'skip';
+          });
 
-        Errors_set(currentErrors);
+          return currentErrors;
+        });
       }
 
       // Finally, set errors for the specific field
diff --git a/src/lib/superValidate.ts b/src/lib/superValidate.ts
@@ -53,7 +53,7 @@ export function message<T extends ZodValidation<AnyZodObject>, M>(
   form.message = message;
   if (options?.status && options.status >= 400) form.valid = false;
 
-  return form.valid ? fail(options?.status ?? 400, { form }) : { form };
+  return !form.valid ? fail(options?.status ?? 400, { form }) : { form };
 }
 
 export const setMessage = message;
diff --git a/src/routes/tests/rex/+page.svelte b/src/routes/tests/rex/+page.svelte
diff --git a/src/routes/tests/rex/schema.ts b/src/routes/tests/rex/schema.ts

Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ export function message<T extends ZodValidation<AnyZodObject>, M>(`
`53`	`53`	`form.message = message;`
`54`	`54`	`if (options?.status && options.status >= 400) form.valid = false;`
`55`	`55`
`56`		`- return form.valid ? fail(options?.status ?? 400, { form }) : { form };`
	`56`	`+ return !form.valid ? fail(options?.status ?? 400, { form }) : { form };`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`export const setMessage = message;`