formFieldProxy and setError are now using StringPathLeaves.

Author: ciscoheat

src/index.test.ts

@@ -173,12 +173,11 @@ test('Nullable values', async () => {
     })
     .refine((data) => data);
 
-  const schema = refinedSchema._def.schema;
-
-  const output = defaultValues(schema);
+  const output = defaultValues(refinedSchema);
   expect(output.scopeId).equals(0);
   expect(output.name).equals(null);
 
+  const schema = refinedSchema._def.schema;
   const extended = schema
     .extend({
       scopeId: schema.shape.scopeId.default(7)

src/lib/client/proxies.ts

@@ -10,6 +10,7 @@ import type { z, AnyZodObject } from 'zod';
 import {
   splitPath,
   type StringPath,
+  type StringPathLeaves,
   type StringPathType
 } from '../stringPath.js';
 
@@ -218,8 +219,16 @@ export type FieldProxy<
 
 export function formFieldProxy<
   T extends AnyZodObject,
-  Path extends string & StringPath<z.infer<T>>
->(form: SuperForm<UnwrapEffects<T>, unknown>, path: Path) {
+  Path extends string & StringPathLeaves<z.infer<T>>
+>(
+  form: SuperForm<UnwrapEffects<T>, unknown>,
+  path: Path
+): {
+  path: Path;
+  value: Writable<StringPathType<z.infer<UnwrapEffects<T>>, Path>>;
+  errors: Writable<string[] | undefined>;
+  constraints: Writable<InputConstraint | undefined>;
+} {
   const path2 = splitPath<z.infer<T>>(path);
   // Filter out array indices, the constraints structure doesn't contain these.
   const constraintsPath = (path2 as unknown[])

src/lib/schemaEntity.ts

@@ -1,4 +1,10 @@
-import type { InputConstraints, InputConstraint } from './index.js';
+import {
+  type InputConstraints,
+  type InputConstraint,
+  type ZodValidation,
+  type UnwrapEffects,
+  SuperFormError
+} from './index.js';
 
 import type { ZodTypeInfo } from './traversal.js';
 
@@ -9,7 +15,7 @@ import {
   type ZodDefault,
   type ZodNullable,
   type ZodOptional,
-  type ZodEffects,
+  ZodEffects,
   ZodString,
   ZodNumber,
   ZodBoolean,
@@ -235,26 +241,32 @@ export function valueOrDefault(
  * Returns the default values for a zod validation schema.
  * The main gotcha is that undefined values are changed to null if the field is nullable.
  */
-export function defaultValues<T extends AnyZodObject>(
+export function defaultValues<T extends ZodValidation<AnyZodObject>>(
   schema: T
-): z.infer<T> {
-  const fields = Object.keys(schema.keyof().Values);
+): z.infer<UnwrapEffects<T>> {
+  while (schema instanceof ZodEffects) {
+    schema = (schema as ZodEffects<T>)._def.schema;
+  }
 
-  let output: Record<string, unknown> = {};
+  if (!(schema instanceof ZodObject)) {
+    throw new SuperFormError(
+      'Only Zod schema objects can be used with defaultValues. ' +
+        'Define the schema with z.object({ ... }) and optionally refine/superRefine/transform at the end.'
+    );
+  }
 
-  const schemaTypeInfo = schemaInfo(schema);
+  const realSchema = schema as UnwrapEffects<T>;
+  const fields = Object.keys(realSchema.keyof().Values);
+  const schemaTypeInfo = schemaInfo(realSchema);
 
-  // Need to set empty properties after defaults are set.
-  output = Object.fromEntries(
+  return Object.fromEntries(
     fields.map((field) => {
       const typeInfo = schemaTypeInfo[field];
       const newValue = valueOrDefault(undefined, true, true, typeInfo);
 
       return [field, newValue];
     })
   );
-
-  return output;
 }
 
 function constraints<T extends AnyZodObject>(

src/lib/stringPath.ts

@@ -1,12 +1,37 @@
 import type { FieldPath } from './index.js';
 
-export function splitPath<T extends object>(path: StringPath<T>) {
+/*
+type Expand<T> = T extends (...args: infer A) => infer R
+  ? (...args: Expand<A>) => Expand<R>
+  : T extends infer O
+  ? { [K in keyof O]: O[K] }
+  : never;
+
+type ExpandRecursively<T> = T extends (...args: infer A) => infer R
+  ? (...args: ExpandRecursively<A>) => ExpandRecursively<R>
+  : T extends object
+  ? T extends infer O
+    ? { [K in keyof O]: ExpandRecursively<O[K]> }
+    : never
+  : T;
+
+type FilterObjects<T extends object> = {
+  [K in keyof T]: T[K] extends object ? never : K;
+}[keyof T];
+*/
+
+export function splitPath<T extends object>(
+  path: StringPath<T> | StringPathLeaves<T>
+) {
   return path
     .toString()
     .split(/[[\].]+/)
     .filter((p) => p) as FieldPath<T>;
 }
 
+/**
+ * Lists all paths in an object as string accessors.
+ */
 export type StringPath<T extends object> = NonNullable<T> extends (infer U)[]
   ? NonNullable<U> extends object
     ?
@@ -33,6 +58,38 @@ export type StringPath<T extends object> = NonNullable<T> extends (infer U)[]
         }[keyof T]
   : never;
 
+/**
+ * Like StringPath, but only with non-objects as accessible properties.
+ * As the leaves in a node tree, if you look at the object as a tree structure.
+ */
+export type StringPathLeaves<T extends object> =
+  NonNullable<T> extends (infer U)[]
+    ? NonNullable<U> extends object
+      ? `[${number}]${U extends unknown[]
+          ? ''
+          : '.'}${NonNullable<U> extends Date
+          ? never
+          : StringPathLeaves<NonNullable<U>> & string}`
+      : `[${number}]`
+    : NonNullable<T> extends object
+    ?
+        | {
+            // Same as FilterObjects but inlined for better intellisense
+            [K in keyof T]: T[K] extends object ? never : K;
+          }[keyof T]
+        | {
+            [K in keyof T]-?: K extends string
+              ? NonNullable<T[K]> extends object
+                ? `${K}${NonNullable<T[K]> extends unknown[]
+                    ? ''
+                    : '.'}${NonNullable<T[K]> extends Date
+                    ? never
+                    : StringPathLeaves<NonNullable<T[K]>> & string}`
+                : never
+              : never;
+          }[keyof T]
+    : never;
+
 export type StringPathType<T, P extends string> = P extends keyof T
   ? T[P]
   : P extends number

src/lib/superValidate.ts

@@ -35,7 +35,7 @@ import {
   type SafeParseReturnType
 } from 'zod';
 
-import { splitPath, type StringPath } from './stringPath.js';
+import { splitPath, type StringPathLeaves } from './stringPath.js';
 
 import { clone } from './utils.js';
 
@@ -63,7 +63,7 @@ export const setMessage = message;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function setError<T extends ZodValidation<AnyZodObject>>(
   form: Validation<T, unknown>,
-  path: StringPath<z.infer<UnwrapEffects<T>>>,
+  path: StringPathLeaves<z.infer<UnwrapEffects<T>>>,
   error: string | string[],
   options: { overwrite?: boolean; status?: number } = {
     overwrite: false,

src/lib/traversal.ts

@@ -46,6 +46,7 @@ export function mapErrors<T extends AnyZodObject>(
   return output as ValidationErrors<T>;
 }
 
+// TODO: Can path be a StringPath?
 export function findErrors(
   errors: ValidationErrors<AnyZodObject>,
   path: string[] = []

src/paths.test-d.ts

@@ -1,5 +1,9 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import type { StringPath, StringPathType } from '$lib/stringPath';
+import type {
+  StringPath,
+  StringPathType,
+  StringPathLeaves
+} from '$lib/stringPath';
 import { test } from 'vitest';
 
 type Obj = {
@@ -70,3 +74,19 @@ test('StringPathType', () => {
   // @ts-expect-error incorrect path
   const n2: StringPathType<Obj, 'nope incorrect'> = 'never';
 });
+
+test('StringPathLeaves', () => {
+  const o = {
+    test: [1, 2, 3],
+    name: 'name',
+    other: [{ test: 'a', ok: 123 }, { test: 'b' }],
+    obj: {
+      ok: 123,
+      arr: [1, 2, 3],
+      test: '1231231',
+      next: [{ level: 1 }, { level: 2 }]
+    }
+  };
+
+  const p: StringPathLeaves<typeof o> = 'test[3]';
+});