Zod 4 adapter passing tests

Author: ciscoheat

package.json

@@ -122,7 +122,7 @@
 		"svelte": "3.x || 4.x || >=5.0.0-next.51",
 		"valibot": ">=1.0.0-rc.3",
 		"yup": "^1.4.0",
-		"zod": "^3.24.2"
+		"zod": "^3.25.0"
 	},
 	"peerDependenciesMeta": {
 		"@exodus/schemasafe": {

src/lib/adapters/adapters.ts

@@ -33,6 +33,7 @@ export type ValidationLibrary =
 	| 'valibot'
 	| 'yup'
 	| 'zod'
+	| 'zod4'
 	| 'vine'
 	| 'schemasafe'
 	| 'superstruct'

src/lib/adapters/typeSchema.ts

@@ -15,6 +15,7 @@ import type {
 } from 'valibot';
 import type { Schema as Schema$2, InferType } from 'yup';
 import type { ZodTypeAny, input, output } from 'zod';
+import type { $ZodType, input as zod4Input, output as zod4Output } from 'zod/v4/core';
 import type { SchemaTypes, Infer as VineInfer } from '@vinejs/vine/types';
 import type { FromSchema, JSONSchema } from 'json-schema-to-ts';
 import type { Struct, Infer as Infer$2 } from 'superstruct';
@@ -133,6 +134,12 @@ interface ZodResolver extends Resolver {
 	output: this['schema'] extends ZodTypeAny ? output<this['schema']> : never;
 }
 
+interface Zod4Resolver extends Resolver {
+	base: $ZodType;
+	input: this['schema'] extends $ZodType ? zod4Input<this['schema']> : never;
+	output: this['schema'] extends $ZodType ? zod4Output<this['schema']> : never;
+}
+
 interface VineResolver extends Resolver {
 	base: SchemaTypes;
 	input: this['schema'] extends SchemaTypes
@@ -207,6 +214,7 @@ export type Registry = {
 	valibot: ValibotResolver;
 	yup: YupResolver;
 	zod: ZodResolver;
+	zod4: Zod4Resolver;
 	vine: VineResolver;
 	schemasafe: SchemasafeResolver<JSONSchema>;
 	superstruct: SuperstructResolver;

src/lib/adapters/zod4.ts

@@ -0,0 +1,78 @@
+import { type $ZodObject, type $ZodErrorMap, safeParseAsync, toJSONSchema } from 'zod/v4/core';
+import type { JSONSchema7 } from 'json-schema';
+import {
+	type AdapterOptions,
+	type ValidationAdapter,
+	type Infer,
+	type InferIn,
+	createAdapter,
+	type ValidationResult,
+	type ClientValidationAdapter
+} from './adapters.js';
+import { memoize } from '$lib/memoize.js';
+
+type Options = NonNullable<Parameters<typeof toJSONSchema>[1]>;
+
+type ZodObject = $ZodObject;
+
+const defaultJSONSchemaOptions = {
+	unrepresentable: 'any',
+	override: (ctx) => {
+		const def = ctx.zodSchema._zod.def;
+		if (def.type === 'date') {
+			ctx.jsonSchema.type = 'string';
+			ctx.jsonSchema.format = 'date-time';
+		}
+	}
+} satisfies Options;
+
+/* @__NO_SIDE_EFFECTS__ */
+export const zodToJSONSchema = <S extends ZodObject>(schema: S, options?: Options) => {
+	return toJSONSchema(schema, { ...defaultJSONSchemaOptions, ...options }) as JSONSchema7;
+};
+
+async function validate<T extends ZodObject>(
+	schema: T,
+	data: unknown,
+	error: $ZodErrorMap | undefined
+): Promise<ValidationResult<Infer<T, 'zod4'>>> {
+	const result = await safeParseAsync(schema, data, { error });
+	if (result.success) {
+		return {
+			data: result.data as Infer<T, 'zod4'>,
+			success: true
+		};
+	}
+
+	return {
+		issues: result.error.issues.map(({ message, path }) => ({ message, path })),
+		success: false
+	};
+}
+
+function _zod4<T extends ZodObject>(
+	schema: T,
+	options?: AdapterOptions<Infer<T, 'zod4'>> & { error?: $ZodErrorMap; config?: Options }
+): ValidationAdapter<Infer<T, 'zod4'>, InferIn<T, 'zod4'>> {
+	return createAdapter({
+		superFormValidationLibrary: 'zod4',
+		validate: async (data) => {
+			return validate(schema, data, options?.error);
+		},
+		jsonSchema: options?.jsonSchema ?? zodToJSONSchema(schema, options?.config),
+		defaults: options?.defaults
+	});
+}
+
+function _zod4Client<T extends ZodObject>(
+	schema: T,
+	options?: { error?: $ZodErrorMap }
+): ClientValidationAdapter<Infer<T, 'zod4'>, InferIn<T, 'zod4'>> {
+	return {
+		superFormValidationLibrary: 'zod4',
+		validate: async (data) => validate(schema, data, options?.error)
+	};
+}
+
+export const zod4 = /* @__PURE__ */ memoize(_zod4);
+export const zod4Client = /* @__PURE__ */ memoize(_zod4Client);

src/lib/formData.ts

@@ -199,7 +199,17 @@ function _parseFormData<T extends Record<string, unknown>>(
 			throw new SchemaError(unionError, key);
 		}
 
-		const [type] = info.types;
+		let [type] = info.types;
+
+		if (!info.types.length && info.schema.enum) {
+			// Special case for Typescript enums
+			// If the entry is an integer, parse it as such, otherwise string
+			if (info.schema.enum.includes(entry)) type = 'string';
+			else {
+				type = Number.isInteger(parseInt(entry, 10)) ? 'integer' : 'string';
+			}
+		}
+
 		return parseFormDataEntry(key, entry, type ?? 'any', info);
 	}
 

src/lib/jsonSchema/schemaDefaults.ts

@@ -97,17 +97,21 @@ function _defaultValues(schema: JSONSchema, isOptional: boolean, path: string[])
 			}
 
 			// Objects must have default values to avoid setting undefined properties on nested data
-			if (info.union.length && info.types[0] == 'object') {
-				if (output === undefined) output = {};
-				output =
-					info.union.length > 1
-						? merge.withOptions(
-								{ allowUndefinedOverrides: true },
-								...info.union.map(
-									(s) => _defaultValues(s, isOptional, path) as Record<string, unknown>
+			if (info.union.length) {
+				if (info.types[0] == 'object') {
+					if (output === undefined) output = {};
+					output =
+						info.union.length > 1
+							? merge.withOptions(
+									{ allowUndefinedOverrides: true },
+									...info.union.map(
+										(s) => _defaultValues(s, isOptional, path) as Record<string, unknown>
+									)
 								)
-							)
-						: (_defaultValues(info.union[0], isOptional, path) as Record<string, unknown>);
+							: (_defaultValues(info.union[0], isOptional, path) as Record<string, unknown>);
+				} else {
+					return _defaultValues(info.union[0], isOptional, path);
+				}
 			}
 		}
 	}
@@ -149,6 +153,11 @@ function _defaultValues(schema: JSONSchema, isOptional: boolean, path: string[])
 		return schema.enum[0];
 	}
 
+	// Constants
+	if ('const' in schema) {
+		return schema.const;
+	}
+
 	// Basic type
 	if (isMultiTypeUnion()) {
 		throw new SchemaError('Default values cannot have more than one type.', path);

src/tests/data.ts

@@ -1,4 +1,6 @@
 import { z } from 'zod';
+import { z as z4 } from 'zod/v4';
+
 import { zodToJSONSchema } from '$lib/adapters/zod.js';
 
 export enum Foo {
@@ -27,6 +29,27 @@ export const bigZodSchema = z.object({
 	})
 });
 
+export const bigZod4Schema = z4.object({
+	name: z4.union([z4.string().default('B'), z4.number()]).default('A'),
+	email: z4.email(),
+	tags: z4.string().min(2).array().min(2).default(['A']),
+	foo: z4.enum(Foo).default(Foo.A),
+	set: z4.set(z4.string()),
+	reg1: z4.string().regex(/\D/).regex(/p/),
+	reg: z4.string().regex(/X/).min(3).max(30),
+	num: z4.number().int().multipleOf(5).min(10).max(100),
+	date: z4.date().min(new Date('2022-01-01')),
+	arr: z4
+		.union([z4.string().min(10), z4.date()])
+		.array()
+		.min(3)
+		.max(10),
+	nestedTags: z4.object({
+		id: z4.number().int().positive().optional(),
+		name: z4.string().min(1)
+	})
+});
+
 export const bigJsonSchema = zodToJSONSchema(bigZodSchema);
 
 ///// From legacy tests /////