Merge pull request #352 from TheEdoRan/fix-validation-errors-v7

Author: TheEdoRan

packages/next-safe-action/src/__tests__/validation-errors.test.ts

@@ -74,6 +74,44 @@ test("action with invalid input gives back an object with correct `validationErr
 	assert.deepStrictEqual(actualResult, expectedResult);
 });
 
+test("action with invalid enum input gives back an object with correct `validationErrors` (default formatted shape)", async () => {
+	const schema = z.object({
+		foo: z.object({
+			bar: z.union([z.literal("a"), z.literal("b")]),
+		}),
+		baz: z.string().min(3),
+	});
+
+	const action = dac.schema(schema).action(async () => {
+		return {
+			ok: true,
+		};
+	});
+
+	const actualResult = await action({
+		foo: {
+			// @ts-expect-error
+			bar: "c",
+		},
+		baz: "a",
+	});
+
+	const expectedResult = {
+		validationErrors: {
+			foo: {
+				bar: {
+					_errors: ['Invalid literal value, expected "a"', 'Invalid literal value, expected "b"'],
+				},
+			},
+			baz: {
+				_errors: ["String must contain at least 3 character(s)"],
+			},
+		},
+	};
+
+	assert.deepStrictEqual(actualResult, expectedResult);
+});
+
 test("action with root level schema error gives back an object with correct `validationErrors` (default formatted shape)", async () => {
 	const userId = "invalid_uuid";
 

packages/next-safe-action/src/adapters/types.ts

@@ -57,29 +57,47 @@ export interface ValidationAdapter {
 	validate<S extends Schema>(
 		schema: S,
 		data: unknown
-	): Promise<{ success: true; data: Infer<S> } | { success: false; issues: ValidationIssue[] }>;
+	): Promise<
+		| { success: true; data: Infer<S> }
+		| { success: false; issues: ValidationIssue[]; unionErrors?: { issues: ValidationIssue[] }[] }
+	>;
 	// zod
 	validate<S extends IfInstalled<z.ZodType>>(
 		schema: S,
 		data: unknown
-	): Promise<{ success: true; data: Infer<S> } | { success: false; issues: ValidationIssue[] }>;
+	): Promise<
+		| { success: true; data: Infer<S> }
+		| { success: false; issues: ValidationIssue[]; unionErrors?: { issues: ValidationIssue[] }[] }
+	>;
 	// valibot
 	validate<S extends IfInstalled<GenericSchema>>(
 		schema: S,
 		data: unknown
-	): Promise<{ success: true; data: Infer<S> } | { success: false; issues: ValidationIssue[] }>;
+	): Promise<
+		| { success: true; data: Infer<S> }
+		| { success: false; issues: ValidationIssue[]; unionErrors?: { issues: ValidationIssue[] }[] }
+	>;
 	validate<S extends IfInstalled<GenericSchemaAsync>>(
 		schema: S,
 		data: unknown
-	): Promise<{ success: true; data: Infer<S> } | { success: false; issues: ValidationIssue[] }>;
+	): Promise<
+		| { success: true; data: Infer<S> }
+		| { success: false; issues: ValidationIssue[]; unionErrors?: { issues: ValidationIssue[] }[] }
+	>;
 	// yup
 	validate<S extends IfInstalled<YupSchema>>(
 		schema: S,
 		data: unknown
-	): Promise<{ success: true; data: Infer<S> } | { success: false; issues: ValidationIssue[] }>;
+	): Promise<
+		| { success: true; data: Infer<S> }
+		| { success: false; issues: ValidationIssue[]; unionErrors?: { issues: ValidationIssue[] }[] }
+	>;
 	// typebox
 	validate<S extends IfInstalled<TSchema>>(
 		schema: S,
 		data: unknown
-	): Promise<{ success: true; data: Infer<S> } | { success: false; issues: ValidationIssue[] }>;
+	): Promise<
+		| { success: true; data: Infer<S> }
+		| { success: false; issues: ValidationIssue[]; unionErrors?: { issues: ValidationIssue[] }[] }
+	>;
 }

packages/next-safe-action/src/adapters/zod.ts

@@ -38,7 +38,9 @@ class ZodAdapter implements ValidationAdapter {
 
 		return {
 			success: false,
-			issues: result.error.issues.map(({ message, path }) => ({ message, path })),
+			// @ts-expect-error
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+			issues: result.error.issues.map(({ message, path, unionErrors }) => ({ message, path, unionErrors })),
 		} as const;
 	}
 }

packages/next-safe-action/src/utils.types.ts

@@ -5,3 +5,6 @@ export type Prettify<T> = {
 
 // Returns type or promise of type.
 export type MaybePromise<T> = Promise<T> | T;
+
+// Returns type or array of type.
+export type MaybeArray<T> = T | T[];

packages/next-safe-action/src/validation-errors.ts

@@ -1,18 +1,26 @@
 /* eslint-disable @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment */
 
-import type { Schema, ValidationIssue } from "./adapters/types";
+import type { Schema } from "./adapters/types";
 import type {
 	FlattenedBindArgsValidationErrors,
 	FlattenedValidationErrors,
+	IssueWithUnionErrors,
 	ValidationErrors,
 } from "./validation-errors.types";
 
+const getIssueMessage = (issue: IssueWithUnionErrors) => {
+	if (issue.unionErrors) {
+		return issue.unionErrors.map((u) => u.issues.map((i) => i.message)).flat();
+	}
+	return issue.message;
+};
+
 // This function is used internally to build the validation errors object from a list of validation issues.
-export const buildValidationErrors = <S extends Schema | undefined>(issues: ValidationIssue[]) => {
+export const buildValidationErrors = <S extends Schema | undefined>(issues: IssueWithUnionErrors[]) => {
 	const ve: any = {};
 
 	for (const issue of issues) {
-		const { path, message } = issue;
+		const { path, message, unionErrors } = issue;
 
 		// When path is undefined or empty, set root errors.
 		if (!path || path.length === 0) {
@@ -37,13 +45,15 @@ export const buildValidationErrors = <S extends Schema | undefined>(issues: Vali
 		// Key is always the last element of the path.
 		const key = path[path.length - 1]!;
 
+		const issueMessage = getIssueMessage(issue);
+
 		// Set error for the current path. If `_errors` array exists, add the message to it.
 		ref[key] = ref[key]?._errors
 			? {
 					...structuredClone(ref[key]),
-					_errors: [...ref[key]._errors, message],
+					_errors: [...ref[key]._errors, issueMessage],
 				}
-			: { ...structuredClone(ref[key]), _errors: [message] };
+			: { ...structuredClone(ref[key]), _errors: unionErrors ? issueMessage : [issueMessage] };
 	}
 
 	return ve as ValidationErrors<S>;

packages/next-safe-action/src/validation-errors.types.ts

@@ -1,23 +1,27 @@
-import type { Infer, InferIn, Schema } from "./adapters/types";
-import type { Prettify } from "./utils.types";
+import type { Infer, InferIn, Schema, ValidationIssue } from "./adapters/types";
+import type { MaybeArray, Prettify } from "./utils.types";
 
 // Basic types and arrays.
 type NotObject = number | string | boolean | bigint | symbol | null | undefined | any[];
 
 // Object with an optional list of validation errors.
-type VEList = Prettify<{ _errors?: string[] }>;
+type VEList<K = undefined> = K extends any[] ? MaybeArray<{ _errors?: string[] }> : { _errors?: string[] };
 
 // Creates nested schema validation errors type using recursion.
 type SchemaErrors<S> = {
-	[K in keyof S]?: S[K] extends NotObject ? VEList : Prettify<VEList & SchemaErrors<S[K]>>;
+	[K in keyof S]?: S[K] extends NotObject ? VEList<S[K]> : Prettify<VEList & SchemaErrors<S[K]>>;
 } & {};
 
+export type IssueWithUnionErrors = ValidationIssue & {
+	unionErrors?: { issues: ValidationIssue[] }[];
+};
+
 /**
  * Type of the returned object when validation fails.
  */
 export type ValidationErrors<S extends Schema | undefined> = S extends Schema
 	? Infer<S> extends NotObject
-		? VEList
+		? Prettify<VEList>
 		: Prettify<VEList & SchemaErrors<Infer<S>>>
 	: undefined;