refactor: Migrate config schema from Zod v3 to Zod v4 (#2357)

tests/utils/zod/parse-errors.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it } from 'vitest';
+import { z, ZodError } from 'zod';
+import { getParseError, getParseErrorPaths } from '../../../src/utils/zod/parse-errors';
+
+describe('getParseErrorPaths', () => {
+  it('should get error paths', () => {
+    const result = z
+      .object({ a: z.string(), b: z.number() })
+      .safeParse({ a: 1, b: 'a' });
+    if (result.success) return;
+    expect(getParseErrorPaths(result.error)).toEqual(new Set(['a', 'b']));
+  });
+
+  it('should get nested error paths', () => {
+    const result = z
+      .object({ a: z.object({ b: z.string() }) })
+      .safeParse({ a: { b: 1 } });
+    if (result.success) return;
+    expect(getParseErrorPaths(result.error)).toEqual(new Set(['a.b']));
+  });
+
+  it('should get array error paths', () => {
+    const result = z.array(z.string()).safeParse([1, 'a', 2]);
+    if (result.success) return;
+    expect(getParseErrorPaths(result.error)).toEqual(new Set(['[0]', '[2]']));
+  });
+
+  it('should get complex nested error paths', () => {
+    const result = z
+      .object({ a: z.array(z.object({ b: z.string() })) })
+      .safeParse({ a: [{ b: 1 }, { b: 'a' }, { b: 2 }] });
+    if (result.success) return;
+    expect(getParseErrorPaths(result.error)).toEqual(new Set(['a[0].b', 'a[2].b']));
+  });
+});
+
+describe('getParseError', () => {
+  it('should get simple error paths', () => {
+    const result = z.object({ required: z.string() }).safeParse({});
+    expect(result.success).toBeFalsy();
+    if (result.success) {
+      return;
+    }
+    expect(getParseError(result.error)).toBe('[\n "required"\n]');
+  });
+
+  it('should get union error paths', () => {
+    const type_one = z.object({ type: z.string(), data: z.string() });
+    const type_two = z.object({ type: z.literal('two'), data: z.string() });
+
+    const schema = z.object({
+      array: type_one.or(type_two).array(),
+    });
+
+    const result = schema.safeParse({ array: [{}] });
+    expect(result.success).toBeFalsy();
+    if (result.success) {
+      return;
+    }
+    expect(getParseError(result.error)).toBe(
+      '[\n "array[0].type",\n "array[0].data"\n]',
+    );
+  });
+
+  it('should get root union error paths', () => {
+    const schema = z.union([z.object({ a: z.string() }), z.object({ b: z.string() })]);
+
+    const result = schema.safeParse({});
+    expect(result.success).toBeFalsy();
+    if (result.success) {
+      return;
+    }
+
+    expect(getParseError(result.error)).toBe('[\n "a",\n "b"\n]');
+  });
+
+  it('should get no paths for empty error', () => {
+    expect(getParseError(new ZodError([]))).toBeNull();
+  });
+});