Implemented path overrides in .refine

Author: Colin McDonnell

README.md

@@ -34,11 +34,12 @@ If you find this package useful, leave a star to help more folks find it ⭐️
 - [Strings](#strings)
 - [Numbers](#numbers)
 - [Objects](#objects)
-  - [.nonstrict](#unknown-keys)
+  - [.shape](#shape-property)
   - [.merge](#merging)
-  - [.extend](#extending)
+  - [.extend](#extending-objects)
   - [.pick/.omit](#masking)
   - [.partial/.deepPartial](#partials)
+  - [.nonstrict](#unknown-keys)
 - [Records](#records)
 - [Arrays](#arrays)
   - [.nonempty](#non-empty-lists)
@@ -184,28 +185,68 @@ const process = (blob: any) => {
 };
 ```
 
-To learn more about error handling with Zod, jump to [Errors](#errors).
-
 ### Custom validation
 
-`.refine(validator: (data:T)=>any, err?: string)`
+`.refine(validator: (data:T)=>any, params?: RefineParams)`
 
 Zod was designed to mirror TypeScript as closely as possible. But there are many so-called "refinement types" you may wish to check for that can't be represented in TypeScript's type system. For instance: checking that a number is an Int or that a string is a valid email address.
 
 For this instances, you can define custom a validation check on _any_ Zod schema with `.refine`:
 
 ```ts
-const myString = z.string().refine(val => val.length <= 255, "String can't be more than 255 characters");
+const myString = z.string().refine(val => val.length <= 255, {
+  message: "String can't be more than 255 characters",
+});
 ```
 
-Here is the type signature for `.refine`:
-
 As you can see, `.refine` takes two arguments.
 
 1. The first is the validation function. This function takes one input (of type `T` — the inferred type of the schema) and returns `any`. Any truthy value will pass validation. (Prior to zod@1.6.2 the validation function had to return a boolean.)
-2. The second argument is a custom error message. Read more about error handling in Zod [here](#errors)
+2. The second argument is a params object. You can use this to customize certain error-handling behavior:
+
+   ```ts
+   type RefineParams = {
+     // override error message
+     message?: string;
+
+     // override error path
+     path?: (string | number)[];
+
+     // params object you can use to customize message
+     // in error map
+     params?: object;
+   };
+   ```
+
+These params let you define powerful custom behavior. Zod is commonly used for form validation. If you want to verify that "password" and "confirmPassword" match, you can do so like this:
+
+```ts
+z.object({
+  password: z.string(),
+  confirm: z.string(),
+})
+  .refine(data => data.confirm === data.password, {
+    message: "Passwords don't match",
+    path: ['confirm'],
+  })
+  .parse({ password: 'asdf', confirmPassword: 'qwer' });
+```
 
-Check out [validator.js](https://github.com/validatorjs/validator.js) for a bunch of useful string validation functions.
+Because you provided a `path` parameter, the resulting error will be:
+
+```ts
+ZodError {
+  errors: [{
+    "code": "custom_error",
+    "path": [ "confirm" ],
+    "message": "Invalid input."
+  }]
+}
+```
+
+Note that the `path` is set to `["confirm"]`, so you can easily display this error underneath the "Confirm password" textbox.
+
+j
 
 ## Type inference
 
@@ -236,6 +277,8 @@ z.string().url();
 z.string().uuid();
 ```
 
+> Check out [validator.js](https://github.com/validatorjs/validator.js) for a bunch of other useful string validation functions.
+
 ### Custom error messages
 
 Like `.refine`, The final (optional) argument is an object that lets you provide a custom error in the `message` field.
@@ -255,11 +298,9 @@ z.string().uuid({ message: 'Invalid UUID' });
 
 There are a handful of number-specific validations.
 
-The final (optional) argument is a params object that lets you provide a custom error in the `message` field.
-
 ```ts
 z.number().min(5);
-z.number().max(5, { message: 'this👏is👏too👏big' });
+z.number().max(5);
 
 z.number().int(); // value must be an integer
 
@@ -269,6 +310,12 @@ z.number().negative(); //     < 0
 z.number().nonpositive(); //  <= 0
 ```
 
+You can optionally pass in a params object as the second argument to provide a custom error message.
+
+```ts
+z.number().max(5, { message: 'this👏is👏too👏big' });
+```
+
 ## Objects
 
 ```ts
@@ -352,9 +399,9 @@ type Merged = z.infer<typeof merged>;
 
 To "overwrite" existing keys, use `.extend` (documented below).
 
-#### Augmentation
+#### Extending objects
 
-You can augment an object schema with the `.extend` method.
+You can add additional fields an object schema with the `.extend` method.
 
 > Before zod@1.8 this method was called `.augment`. The `augment` method is still available for backwards compatibility but it is deprecated and will be removed in a future release.
 

coverage.svg

@@ -119,7 +119,7 @@ interface TooBigError extends ZodSuberrorBase {
   type: 'array' | 'string' | 'number';
 }
 
-interface CustomError extends ZodSuberrorBase {
+export interface CustomError extends ZodSuberrorBase {
   code: typeof ZodErrorCode.custom_error;
   params?: { [k: string]: any };
 }
@@ -182,4 +182,6 @@ export class ZodError extends Error {
   addErrors = (subs: ZodSuberror[] = []) => {
     this.errors = [...this.errors, ...subs];
   };
+
+  // toFormError =
 }

src/ZodError.ts

@@ -20,21 +20,32 @@ test('refinement', () => {
 });
 
 test('refinement 2', () => {
-  try {
-    const validationSchema = z
-      .object({
-        email: z.string().email(),
-        password: z.string(),
-        confirmPassword: z.string(),
-      })
-      .refine(data => data.password === data.confirmPassword, 'Both password and confirmation must match');
+  const validationSchema = z
+    .object({
+      email: z.string().email(),
+      password: z.string(),
+      confirmPassword: z.string(),
+    })
+    .refine(data => data.password === data.confirmPassword, 'Both password and confirmation must match');
 
+  expect(() =>
     validationSchema.parse({
       email: 'aaaa@gmail.com',
       password: 'aaaaaaaa',
       confirmPassword: 'bbbbbbbb',
+    }),
+  ).toThrow();
+});
+
+test('custom path', () => {
+  z.object({
+    password: z.string(),
+    confirm: z.string(),
+  })
+    .refine(data => data.confirm === data.password, { path: ['confirm'] })
+    .parseAsync({ password: 'asdf', confirm: 'qewr' })
+    .catch(err => {
+      console.log(JSON.stringify(err, null, 2));
+      expect(err.errors[0].path).toEqual(['confirm']);
     });
-  } catch (err) {
-    console.log(JSON.stringify(err.errors, null, 2));
-  }
 });

src/__tests__/refine.test.ts

@@ -63,7 +63,7 @@ export const ZodParsedType = util.arrayToEnum([
 export type ZodParsedType = keyof typeof ZodParsedType;
 
 type StripErrorKeys<T extends object> = T extends any ? util.OmitKeys<T, 'path'> : never;
-export type MakeErrorData = StripErrorKeys<ZodSuberrorOptionalMessage>;
+export type MakeErrorData = StripErrorKeys<ZodSuberrorOptionalMessage> & { path?: (string | number)[] };
 
 export const ZodParser = (schemaDef: z.ZodTypeDef) => (
   obj: any,
@@ -96,7 +96,7 @@ export const ZodParser = (schemaDef: z.ZodTypeDef) => (
         : defaultErrorMap(errorArg, { ...ctxArg, defaultError: `Invalid value.` });
     return {
       ...errorData,
-      path: params.path,
+      path: [...params.path, ...(errorData.path || [])],
       message:
         errorData.message || params.errorMap(errorArg, { ...ctxArg, defaultError: defaultError.message }).message,
     };

src/parser.ts

@@ -1,49 +1,57 @@
 import * as z from '.';
 
-const run = async () => {
-  const errorMap: z.ZodErrorMap = (error, ctx) => {
-    /*
-
-  If error.message is set, that means the user is trying to
-  override the error message. This is how method-specific
-  error overrides work, like this:
-
-  z.string().min(5, { message: "TOO SMALL 🤬" })
-
-  It is a best practice to return `error.message` if it is set.
-  
-  */
-    if (error.message) return { message: error.message };
-
-    /*
-  This is where you override the various error codes
-  */
-    switch (error.code) {
-      case z.ZodErrorCode.invalid_type:
-        if (error.expected === 'string') {
-          return { message: `This ain't a string!` };
-        }
-        break;
-      case z.ZodErrorCode.custom_error:
-        // produce a custom message using error.params
-        // error.params won't be set unless you passed
-        // a `params` arguments into a custom validator
-        const params = error.params || {};
-        if (params.myField) {
-          return { message: `Bad input: ${params.myField}` };
-        }
-        break;
-    }
-
-    // fall back to default message!
-    return { message: ctx.defaultError };
-  };
-
-  try {
-    z.string().parse(12, { errorMap });
-  } catch (err) {
-    console.log(JSON.stringify(err.errors, null, 2));
-  }
-};
-
-run();
+z.object({
+  password: z.string(),
+  confirm: z.string(),
+})
+  .refine(data => data.confirm === data.password, { path: ['confirm'] })
+  .parseAsync({ password: 'asdf', confirm: 'qewr' })
+  .catch(err => console.log(JSON.stringify(err, null, 2)));
+
+// const run = async () => {
+//   const errorMap: z.ZodErrorMap = (error, ctx) => {
+//     /*
+
+//   If error.message is set, that means the user is trying to
+//   override the error message. This is how method-specific
+//   error overrides work, like this:
+
+//   z.string().min(5, { message: "TOO SMALL 🤬" })
+
+//   It is a best practice to return `error.message` if it is set.
+
+//   */
+//     if (error.message) return { message: error.message };
+
+//     /*
+//   This is where you override the various error codes
+//   */
+//     switch (error.code) {
+//       case z.ZodErrorCode.invalid_type:
+//         if (error.expected === 'string') {
+//           return { message: `This ain't a string!` };
+//         }
+//         break;
+//       case z.ZodErrorCode.custom_error:
+//         // produce a custom message using error.params
+//         // error.params won't be set unless you passed
+//         // a `params` arguments into a custom validator
+//         const params = error.params || {};
+//         if (params.myField) {
+//           return { message: `Bad input: ${params.myField}` };
+//         }
+//         break;
+//     }
+
+//     // fall back to default message!
+//     return { message: ctx.defaultError };
+//   };
+
+//   try {
+//     z.string().parse(12, { errorMap });
+//   } catch (err) {
+//     console.log(JSON.stringify(err.errors, null, 2));
+//   }
+// };
+
+// run();

src/playground.ts

@@ -1,6 +1,7 @@
 import { ZodParser, ParseParams, MakeErrorData } from '../parser';
 import { util } from '../helpers/util';
 import { ZodErrorCode } from '..';
+import { CustomError } from '../ZodError';
 
 export enum ZodTypes {
   string = 'string',
@@ -40,10 +41,11 @@ type InternalCheck<T> = {
 
 type Check<T> = {
   check: (arg: T) => any;
-  message?: string;
-  params?: { [k: string]: any };
+  // message?: string;
+  path?: (string | number)[];
+  // params?: { [k: string]: any };
   // code?: ZodErrorCode;
-};
+} & util.Omit<CustomError, 'code' | 'path'>;
 export interface ZodTypeDef {
   t: ZodTypes;
   checks?: InternalCheck<any>[];