Fixed union handling with default values

Author: ciscoheat

src/lib/errors.ts

@@ -1,5 +1,5 @@
 import type { SchemaShape } from './jsonSchema/schemaShape.js';
-import { pathExists, setPaths, traversePath, traversePaths } from './traversal.js';
+import { pathExists, setPaths, traversePath, traversePaths, type PathData } from './traversal.js';
 import { mergePath } from './stringPath.js';
 import type { ValidationErrors } from './superValidate.js';
 import { defaultTypes, defaultValue, type SchemaFieldType } from './jsonSchema/schemaDefaults.js';
@@ -168,6 +168,7 @@ export function replaceInvalidDefaults<T extends Record<string, unknown>>(
 
 	//#region Types
 
+	// TODO: Memoize Types with _schema?
 	const Types = defaultTypes(_schema);
 
 	function Types_correctValue(dataValue: unknown, defValue: unknown, type: SchemaFieldType) {
@@ -249,11 +250,7 @@ export function replaceInvalidDefaults<T extends Record<string, unknown>>(
 	//#region Defaults
 
 	function Defaults_traverseAndReplace(
-		defaultPath: {
-			path: (string | number | symbol)[];
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			value: any;
-		},
+		defaultPath: Partial<PathData>,
 		traversingErrors = false
 	): void {
 		const currentPath = defaultPath.path;

src/lib/jsonSchema/schemaDefaults.ts

@@ -244,17 +244,24 @@ type SchemaTypeObject = {
 	[Key in Exclude<string, '_types' | '_items'>]: SchemaTypeObject;
 } & SchemaFieldType;
 
-function _defaultTypes(schema: JSONSchema, isOptional: boolean, path: string[]) {
+function _defaultTypes(schema: JSONSchema, isOptional: boolean, path: string[]): SchemaTypeObject {
 	if (!schema) {
 		throw new SchemaError('Schema was undefined', path);
 	}
 
 	const info = schemaInfo(schema, isOptional, path);
 
-	const output = {
+	let output = {
 		__types: info.types
 	} as SchemaTypeObject;
 
+	if (info.union) {
+		output = merge(
+			output,
+			...info.union.map((u) => _defaultTypes(u, info.isOptional, path))
+		) as SchemaTypeObject;
+	}
+
 	//if (schema.type == 'object') console.log('--- OBJECT ---'); //debug
 	//else console.dir({ path, info }, { depth: 10 }); //debug
 

src/tests/logOnlyFails.ts

@@ -0,0 +1,28 @@
+import { type TestContext } from 'vitest';
+
+const loggers = ['log', 'debug', 'trace', 'info', 'warn', 'error'] as const;
+
+type LogFunction = (...args: unknown[]) => void;
+type LoggedInvocation = [LogFunction, unknown[]];
+
+export const logOnlyFails = (ctx: TestContext) => {
+	const logs: LoggedInvocation[] = [];
+
+	const original: Record<string, LogFunction> = {};
+	for (const logger of loggers) {
+		original[logger] = console[logger];
+		console[logger] = (...args) => logs.push([original[logger], args]);
+	}
+
+	ctx.onTestFailed(() => {
+		for (const [logger, data] of logs) {
+			logger.call(console, ...data);
+		}
+	});
+
+	return () => {
+		for (const logger of loggers) {
+			console[logger] = original[logger];
+		}
+	};
+};

src/tests/superValidate.test.ts

@@ -443,8 +443,10 @@ describe('Arktype', () => {
 				expect(form.valid).toBe(false);
 				expect(form.errors.id).toBeTruthy();
 			});
+		});
+	});
 
-  describe('with optional properties', () => {
+	describe('with optional properties', () => {
 		const schema = type({
 			name: 'string',
 			'email?': 'string.email',

src/tests/zod4Union.test.ts

@@ -56,6 +56,69 @@ describe('New discriminatedUnion features', () => {
 		assert(form.data.message === 'FAIL');
 		assert(form.data.code === 401);
 	});
+
+	test('A complicated union', async () => {
+		const ZodSchema2 = z.discriminatedUnion('type', [
+			z.object({
+				type: z.literal('empty')
+			}),
+			z.object({
+				type: z.literal('additional'),
+				additional: z.discriminatedUnion('type', [
+					z.object({
+						type: z.literal('poBox'),
+						name: z
+							.string()
+							.min(1, 'min len')
+							.max(10, 'max len')
+							.default(null as unknown as string)
+					}),
+					z.object({
+						type: z.literal('none')
+					})
+				])
+			})
+		]);
+
+		const FormSchema = zod(ZodSchema2);
+		type FormSchema = (typeof FormSchema)['defaults'];
+
+		{
+			const data = {
+				type: 'additional',
+				additional: {
+					// @ts-expect-error Testing with invalid data
+					type: 123,
+					name: ''
+				}
+			} satisfies FormSchema;
+
+			// @ts-expect-error Testing with invalid data
+			const form = await validate(data, FormSchema);
+			expect(form.valid).toBe(false);
+			expect(form.data).toEqual({
+				type: 'additional',
+				additional: {
+					type: 'none',
+					name: ''
+				}
+			});
+		}
+
+		{
+			const data = {
+				type: 'additional',
+				additional: {
+					type: 'poBox',
+					name: ''
+				}
+			} satisfies FormSchema;
+
+			const form = await validate(data, FormSchema);
+			expect(form.valid).toBe(false);
+			expect(form.data).toEqual(data);
+		}
+	});
 });
 
 describe('Default discriminated union values 1', () => {