Include received value type in invalid_union_discriminator issues

integration-tests/zod-error-formatter/discriminated-union.test.ts

@@ -12,7 +12,7 @@ test('formats messages for invalid discriminated union schemas correctly', () =>
 
     assert.strictEqual(result.success, false);
     assert.deepStrictEqual(result.error.issues, [
-        'at type: invalid discriminator value, expected one of "foo" or "bar"'
+        'at type: invalid discriminator: expected one of "foo" or "bar", but got number'
     ]);
 });
 
@@ -25,6 +25,19 @@ test('formats messages for invalid discriminated union schemas correctly when th
 
     assert.strictEqual(result.success, false);
     assert.deepStrictEqual(result.error.issues, [
-        'at type: invalid discriminator value, expected one of "foo" or "bar"'
+        'at type: missing property'
+    ]);
+});
+
+test('formats messages for invalid discriminated union schemas correctly when discriminator is undefined', () => {
+    const schema = z.discriminatedUnion('type', [
+        z.object({ type: z.literal('foo'), data: z.number() }),
+        z.object({ type: z.literal('bar'), data: z.boolean() })
+    ]);
+    const result = safeParse(schema, { type: undefined });
+
+    assert.strictEqual(result.success, false);
+    assert.deepStrictEqual(result.error.issues, [
+        'at type: invalid discriminator: expected one of "foo" or "bar", but got undefined'
     ]);
 });

source/zod-error-formatter/format-issue.test.ts

@@ -4,12 +4,12 @@ import { ZodError } from 'zod';
 import { formatIssue } from './format-issue.js';
 
 test('returns just the message when the path is empty', () => {
-    const formattedIssue = formatIssue({ code: 'custom', message: 'foo', path: [] });
+    const formattedIssue = formatIssue({ code: 'custom', message: 'foo', path: [] }, '');
     assert.strictEqual(formattedIssue, 'invalid input');
 });
 
 test('returns the message with path when the path is not empty', () => {
-    const formattedIssue = formatIssue({ code: 'custom', message: 'bar', path: ['foo'] });
+    const formattedIssue = formatIssue({ code: 'custom', message: 'bar', path: ['foo'] }, '');
     assert.strictEqual(formattedIssue, 'at foo: invalid input');
 });
 
@@ -20,7 +20,7 @@ test('returns the formatted issue when an invalid_type issue is given', () => {
         expected: 'nan',
         received: 'float',
         path: ['foo']
-    });
+    }, '');
     assert.strictEqual(formattedIssue, 'at foo: expected nan, but got float');
 });
 
@@ -31,7 +31,7 @@ test('returns the formatted issue when an invalid_literal issue is given', () =>
         expected: 'foo',
         received: 'bar',
         path: ['foo']
-    });
+    }, '');
     assert.strictEqual(formattedIssue, 'at foo: invalid literal: expected "foo", but got string');
 });
 
@@ -41,7 +41,7 @@ test('returns the formatted issue when an unrecognized_keys issue is given', ()
         message: '',
         keys: ['bar'],
         path: ['foo']
-    });
+    }, '');
     assert.strictEqual(formattedIssue, 'at foo: unexpected additional property: "bar"');
 });
 
@@ -53,7 +53,7 @@ test('returns the formatted issue when an too_big issue is given', () => {
         inclusive: false,
         type: 'string',
         maximum: 2
-    });
+    }, '');
     assert.strictEqual(formattedIssue, 'at foo: string must contain less than 2 characters');
 });
 
@@ -65,7 +65,7 @@ test('returns the formatted issue when an too_small issue is given', () => {
         inclusive: false,
         type: 'string',
         minimum: 2
-    });
+    }, '');
     assert.strictEqual(formattedIssue, 'at foo: string must contain more than 2 characters');
 });
 
@@ -75,7 +75,7 @@ test('returns the formatted issue when an not_multiple_of issue is given', () =>
         path: ['foo'],
         message: '',
         multipleOf: 42
-    });
+    }, '');
     assert.strictEqual(formattedIssue, 'at foo: number must be multiple of 42');
 });
 
@@ -86,7 +86,7 @@ test('returns the formatted issue when an invalid_enum_value issue is given', ()
         message: '',
         options: ['a', 'b'],
         received: 1
-    });
+    }, '');
     assert.strictEqual(formattedIssue, 'at foo: invalid enum value: expected one of "a" or "b", but got number');
 });
 
@@ -96,7 +96,7 @@ test('returns the formatted issue when an invalid_string issue is given', () =>
         path: ['foo'],
         message: '',
         validation: 'ip'
-    });
+    }, '');
     assert.strictEqual(formattedIssue, 'at foo: invalid ip');
 });
 
@@ -106,8 +106,8 @@ test('returns the formatted issue when an invalid_union_discriminator issue is g
         path: ['foo'],
         message: '',
         options: ['a']
-    });
-    assert.strictEqual(formattedIssue, 'at foo: invalid discriminator value, expected "a"');
+    }, { foo: undefined });
+    assert.strictEqual(formattedIssue, 'at foo: invalid discriminator: expected "a", but got undefined');
 });
 
 test('returns the formatted issue when an invalid_union issue is given', () => {
@@ -116,7 +116,7 @@ test('returns the formatted issue when an invalid_union issue is given', () => {
         path: ['foo'],
         message: '',
         unionErrors: []
-    });
+    }, '');
     assert.strictEqual(formattedIssue, 'at foo: invalid value doesn’t match expected union');
 });
 
@@ -126,7 +126,7 @@ test('returns the formatted issue when an invalid_arguments issue is given', ()
         path: ['foo'],
         message: '',
         argumentsError: new ZodError([])
-    });
+    }, '');
     assert.strictEqual(formattedIssue, 'at foo: invalid function arguments');
 });
 
@@ -136,7 +136,7 @@ test('returns the formatted issue when an invalid_return_type issue is given', (
         path: ['foo'],
         message: '',
         returnTypeError: new ZodError([])
-    });
+    }, '');
     assert.strictEqual(formattedIssue, 'at foo: invalid function return type');
 });
 
@@ -145,7 +145,7 @@ test('returns the formatted issue when an invalid_date issue is given', () => {
         code: 'invalid_date',
         path: ['foo'],
         message: ''
-    });
+    }, '');
     assert.strictEqual(formattedIssue, 'at foo: invalid date');
 });
 
@@ -154,7 +154,7 @@ test('returns the formatted issue when a custom issue is given', () => {
         code: 'custom',
         path: ['foo'],
         message: ''
-    });
+    }, '');
     assert.strictEqual(formattedIssue, 'at foo: invalid input');
 });
 
@@ -163,7 +163,7 @@ test('returns the formatted issue when an invalid_intersection_types issue is gi
         code: 'invalid_intersection_types',
         path: ['foo'],
         message: ''
-    });
+    }, '');
     assert.strictEqual(formattedIssue, 'at foo: intersection results could not be merged');
 });
 
@@ -172,6 +172,6 @@ test('returns the formatted issue when an not_finite issue is given', () => {
         code: 'not_finite',
         path: ['foo'],
         message: ''
-    });
+    }, '');
     assert.strictEqual(formattedIssue, 'at foo: number must be finite');
 });

source/zod-error-formatter/format-issue.ts

@@ -12,7 +12,10 @@ import { formatTooSmallIssueMessage } from './issue-specific/too-small.js';
 import { formatUnrecognizedKeysIssueMessage } from './issue-specific/unrecognized-keys.js';
 import { formatPath, isNonEmptyPath } from './path.js';
 
-type FormatterForCode<Code extends ZodIssueCode> = (issue: Extract<ZodIssue, { code: Code; }>) => string;
+type FormatterForCode<Code extends ZodIssueCode> = (
+    issue: Extract<ZodIssue, { code: Code; }>,
+    input: unknown
+) => string;
 
 type FormatterMap = {
     readonly [Key in ZodIssueCode]: FormatterForCode<Key>;
@@ -43,11 +46,11 @@ const issueCodeToFormatterMap: FormatterMap = {
     not_finite: formatSimpleMessage('number must be finite')
 };
 
-export function formatIssue(issue: ZodIssue): string {
+export function formatIssue(issue: ZodIssue, input: unknown): string {
     const { path, code } = issue;
 
-    const formatter = issueCodeToFormatterMap[code] as (issue: ZodIssue) => string;
-    const message = formatter(issue);
+    const formatter = issueCodeToFormatterMap[code] as (issue: ZodIssue, input: unknown) => string;
+    const message = formatter(issue, input);
 
     if (isNonEmptyPath(path)) {
         const formattedPath = formatPath(path);

source/zod-error-formatter/formatter.test.ts

@@ -11,7 +11,7 @@ test('formatZodError() takes a zod error and formats all issues', () => {
     const result = exampleSchema.safeParse({ foo: 42, bar: '' });
 
     assert.strictEqual(result.success, false);
-    const formattedError = formatZodError(result.error);
+    const formattedError = formatZodError(result.error, '');
 
     assert.strictEqual(
         formattedError.message,

source/zod-error-formatter/formatter.ts

@@ -2,8 +2,10 @@ import type { TypeOf, ZodError, ZodSchema } from 'zod';
 import { formatIssue } from './format-issue.js';
 import { createFormattedZodError, type FormattedZodError } from './formatted-error.js';
 
-export function formatZodError(error: ZodError): FormattedZodError {
-    const formattedIssues = error.issues.map(formatIssue);
+export function formatZodError(error: ZodError, input: unknown): FormattedZodError {
+    const formattedIssues = error.issues.map((issue) => {
+        return formatIssue(issue, input);
+    });
     return createFormattedZodError(formattedIssues);
 }
 
@@ -14,7 +16,7 @@ export function parse<Schema extends ZodSchema<unknown>>(schema: Schema, value:
         return result.data;
     }
 
-    throw formatZodError(result.error);
+    throw formatZodError(result.error, value);
 }
 
 type SafeParseSuccessResult<Output> = {
@@ -39,5 +41,5 @@ export function safeParse<Schema extends ZodSchema<unknown>>(
         return { success: true, data: result.data };
     }
 
-    return { success: false, error: formatZodError(result.error) };
+    return { success: false, error: formatZodError(result.error, value) };
 }

source/zod-error-formatter/issue-specific/invalid-union-discriminator.test.ts

@@ -8,8 +8,8 @@ test('formats an invalid union discriminator issue correctly with string options
         path: [],
         message: '',
         options: ['a', 'b', 'c']
-    });
-    assert.strictEqual(message, 'invalid discriminator value, expected one of "a", "b" or "c"');
+    }, '');
+    assert.strictEqual(message, 'invalid discriminator: expected one of "a", "b" or "c", but got string');
 });
 
 test('formats an invalid union discriminator issue correctly with empty options', () => {
@@ -18,8 +18,8 @@ test('formats an invalid union discriminator issue correctly with empty options'
         path: [],
         message: '',
         options: []
-    });
-    assert.strictEqual(message, 'invalid discriminator value, expected unknown');
+    }, '');
+    assert.strictEqual(message, 'invalid discriminator: expected unknown, but got string');
 });
 
 test('formats an invalid union discriminator issue correctly with one option', () => {
@@ -28,8 +28,8 @@ test('formats an invalid union discriminator issue correctly with one option', (
         path: [],
         message: '',
         options: ['a']
-    });
-    assert.strictEqual(message, 'invalid discriminator value, expected "a"');
+    }, '');
+    assert.strictEqual(message, 'invalid discriminator: expected "a", but got string');
 });
 
 test('formats an invalid union discriminator issue correctly with boolean option', () => {
@@ -38,8 +38,8 @@ test('formats an invalid union discriminator issue correctly with boolean option
         path: [],
         message: '',
         options: [false]
-    });
-    assert.strictEqual(message, 'invalid discriminator value, expected false');
+    }, '');
+    assert.strictEqual(message, 'invalid discriminator: expected false, but got string');
 });
 
 test('formats an invalid union discriminator issue correctly with number option', () => {
@@ -48,8 +48,8 @@ test('formats an invalid union discriminator issue correctly with number option'
         path: [],
         message: '',
         options: [1]
-    });
-    assert.strictEqual(message, 'invalid discriminator value, expected 1');
+    }, '');
+    assert.strictEqual(message, 'invalid discriminator: expected 1, but got string');
 });
 
 test('formats an invalid union discriminator issue correctly with undefined option', () => {
@@ -58,8 +58,8 @@ test('formats an invalid union discriminator issue correctly with undefined opti
         path: [],
         message: '',
         options: [undefined]
-    });
-    assert.strictEqual(message, 'invalid discriminator value, expected undefined');
+    }, '');
+    assert.strictEqual(message, 'invalid discriminator: expected undefined, but got string');
 });
 
 test('formats an invalid union discriminator issue correctly with symbol without description option', () => {
@@ -69,8 +69,8 @@ test('formats an invalid union discriminator issue correctly with symbol without
         message: '',
         // eslint-disable-next-line symbol-description -- no description because we want to actually test this case
         options: [Symbol()]
-    });
-    assert.strictEqual(message, 'invalid discriminator value, expected Symbol()');
+    }, '');
+    assert.strictEqual(message, 'invalid discriminator: expected Symbol(), but got string');
 });
 
 test('formats an invalid union discriminator issue correctly with symbol with description option', () => {
@@ -79,6 +79,26 @@ test('formats an invalid union discriminator issue correctly with symbol with de
         path: [],
         message: '',
         options: [Symbol('foo')]
-    });
-    assert.strictEqual(message, 'invalid discriminator value, expected Symbol(foo)');
+    }, '');
+    assert.strictEqual(message, 'invalid discriminator: expected Symbol(foo), but got string');
+});
+
+test('formats an invalid union discriminator issue correctly printing the received type from nested path', () => {
+    const message = formatInvalidUnionDiscriminatorIssueMessage({
+        code: 'invalid_union_discriminator',
+        path: ['foo', 'bar'],
+        message: '',
+        options: ['foo']
+    }, { foo: { bar: true } });
+    assert.strictEqual(message, 'invalid discriminator: expected "foo", but got boolean');
+});
+
+test('formats an invalid union discriminator issue when the property is missing', () => {
+    const message = formatInvalidUnionDiscriminatorIssueMessage({
+        code: 'invalid_union_discriminator',
+        path: ['foo', 'bar'],
+        message: '',
+        options: ['foo']
+    }, { foo: {} });
+    assert.strictEqual(message, 'missing property');
 });

source/zod-error-formatter/issue-specific/invalid-union-discriminator.ts

@@ -1,7 +1,19 @@
-import type { ZodInvalidUnionDiscriminatorIssue } from 'zod';
+import { getParsedType, type ZodInvalidUnionDiscriminatorIssue } from 'zod';
 import { formatOneOfList } from '../list.js';
+import { findValueByPath } from '../path.js';
 
-export function formatInvalidUnionDiscriminatorIssueMessage(issue: ZodInvalidUnionDiscriminatorIssue): string {
-    const formattedOptions = formatOneOfList(issue.options);
-    return `invalid discriminator value, expected ${formattedOptions}`;
+export function formatInvalidUnionDiscriminatorIssueMessage(
+    issue: ZodInvalidUnionDiscriminatorIssue,
+    input: unknown
+): string {
+    const result = findValueByPath(input, issue.path);
+
+    if (result.found) {
+        const formattedOptions = formatOneOfList(issue.options);
+        const receivedValue = result.value;
+        const receivedType = getParsedType(receivedValue);
+        return `invalid discriminator: expected ${formattedOptions}, but got ${receivedType}`;
+    }
+
+    return 'missing property';
 }