Checking if whole object has side-effects.

Author: ciscoheat

src/compare.test.ts

@@ -17,7 +17,7 @@ import {
 import { pathExists, traversePath, traversePathAsync } from '$lib/entity';
 import { get, writable } from 'svelte/store';
 import { mapErrors } from '$lib/entity';
-import { unwrapZodType } from '$lib/server/entity';
+import { hasEffects, unwrapZodType } from '$lib/server/entity';
 import { superValidate } from '$lib/server';
 import {
   booleanProxy,
@@ -457,15 +457,18 @@ test('Check path existence', () => {
   });
 });
 
-/*
-test('String paths', () => {
-  type Social = z.infer<typeof social>;
-  const i = 5;
-  const i2 = '5';
-
-  const path1: StringPath<Social> = `user.tags.${i}.name`;
-  const path2: StringPath<Social> = `user.tags.${i2}.name`;
+const refined = z.object({
+  id: z.number().int().positive(),
+  name: z.string().min(2),
+  email: z.string().email().nullable(),
+  tags: z
+    .object({ name: z.string().min(1) })
+    .refine((data) => data.name.length > 5)
+    .array()
+    .optional()
+});
 
-  expect(path1).toEqual(path2);
+test.only('Checking side effects', () => {
+  expect(hasEffects(social)).toStrictEqual(false);
+  expect(hasEffects(refined)).toStrictEqual(true);
 });
-*/

src/lib/client/index.ts

@@ -52,7 +52,7 @@ import {
 } from '../entity.js';
 import { fieldProxy } from './proxies.js';
 import { clone } from '../utils.js';
-import type { Entity } from '../schemaEntity.js';
+import { hasEffects, type Entity } from '../schemaEntity.js';
 import { unwrapZodType } from '../schemaEntity.js';
 
 enum FetchStatus {
@@ -843,6 +843,8 @@ function shouldSyncFlash<T extends AnyZodObject, M>(
   return options.syncFlashMessage;
 }
 
+const effectMapCache = new WeakMap<object, boolean>();
+
 async function validateField<T extends AnyZodObject, M>(
   path: string[],
   validators: FormOptions<T, M>['validators'],
@@ -940,7 +942,7 @@ async function validateField<T extends AnyZodObject, M>(
       const unwrapped = unwrapZodType(nextType);
       return unwrapped.effects ? undefined : unwrapped.zodType;
     } else if (type._def.typeName == 'ZodArray') {
-      const array = type as ZodArray<ZodAny>;
+      const array = type as ZodArray<ZodTypeAny>;
       const unwrapped = unwrapZodType(array.element);
       if (unwrapped.effects) return undefined;
       return extractValidator(unwrapped, key);
@@ -952,16 +954,24 @@ 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 noEffects = traversePath(
-      validators,
-      validationPath as FieldPath<typeof validators>,
-      (pathData) => {
-        return extractValidator(
-          unwrapZodType(pathData.parent),
-          pathData.key
+    if (!effectMapCache.has(validators)) {
+      effectMapCache.set(validators, hasEffects(validators as ZodTypeAny));
+    }
+
+    const effects = effectMapCache.get(validators);
+
+    const noEffects = effects
+      ? undefined
+      : traversePath(
+          validators,
+          validationPath as FieldPath<typeof validators>,
+          (pathData) => {
+            return extractValidator(
+              unwrapZodType(pathData.parent),
+              pathData.key
+            );
+          }
         );
-      }
-    );
 
     if (noEffects) {
       const validator = extractValidator(

src/lib/schemaEntity.ts

@@ -22,7 +22,8 @@ import {
   ZodBigInt,
   ZodObject,
   ZodSymbol,
-  ZodRecord
+  ZodRecord,
+  ZodAny
 } from 'zod';
 
 export type UnwrappedEntity<T> = T extends ZodOptional<infer U>
@@ -52,6 +53,25 @@ export type Entity<T extends AnyZodObject> = {
   keys: string[];
 };
 
+export function hasEffects(zodType: ZodTypeAny): boolean {
+  const type = unwrapZodType(zodType);
+  if (type.effects) return true;
+
+  const name = type.zodType._def.typeName;
+
+  if (name == 'ZodObject') {
+    const obj = type.zodType as AnyZodObject;
+    for (const field of Object.values(obj._def.shape())) {
+      if (hasEffects(field as ZodTypeAny)) return true;
+    }
+  } else if (name == 'ZodArray') {
+    const array = type.zodType as ZodArray<ZodTypeAny>;
+    return hasEffects(array.element);
+  }
+
+  return false;
+}
+
 export function unwrapZodType(zodType: ZodTypeAny): ZodTypeInfo {
   let _wrapped = true;
   let isNullable = false;