eslint-plugin-zod-v4 0.1.0 → 0.2.0

package/README.md

@@ -12,6 +12,7 @@ ESLint plugin for Zod v4 best practices and migration from v3.
 - Auto-fix support for most rules
 - Educational error messages explaining the correct approach
 - Full ESLint 9+ flat config support
+- **React-aware**: Recognizes `useMemo`/`useCallback` for schema memoization
 
 ## Installation
 
@@ -68,18 +69,18 @@ These rules detect Zod v3 patterns that will break in v4.
 
 | Rule | Description | Fixable |
 |------|-------------|---------|
-| [no-deprecated-string-format](docs/rules/no-deprecated-string-format.md) | Disallow `z.string().email()` etc. Use `z.email()` instead. | Yes |
-| [no-record-single-arg](docs/rules/no-record-single-arg.md) | Require `z.record(keySchema, valueSchema)` with two arguments. | No |
-| [no-deprecated-error-params](docs/rules/no-deprecated-error-params.md) | Disallow `invalid_type_error`/`required_error`. Use `error` param. | Yes |
-| [no-deprecated-format-methods](docs/rules/no-deprecated-format-methods.md) | Disallow `.format()`/`.flatten()` on ZodError. Use `z.treeifyError()`. | No |
-| [no-merge-method](docs/rules/no-merge-method.md) | Disallow `.merge()`. Use `.extend()` instead. | No |
-| [no-superrefine](docs/rules/no-superrefine.md) | Disallow `.superRefine()`. Use `.check()` instead. | No |
-| [no-errors-property](docs/rules/no-errors-property.md) | Disallow `error.errors`. Use `error.issues` instead. | Yes |
-| [no-deprecated-object-methods](docs/rules/no-deprecated-object-methods.md) | Disallow `.strict()`/`.passthrough()`/`.strip()`. Use top-level functions. | No |
-| [no-native-enum](docs/rules/no-native-enum.md) | Disallow `z.nativeEnum()`. Use `z.enum()` instead. | No |
-| [no-deep-partial](docs/rules/no-deep-partial.md) | Disallow `.deepPartial()` (removed in v4). | No |
-| [no-deprecated-ip-methods](docs/rules/no-deprecated-ip-methods.md) | Disallow `.ip()`/`.cidr()`. Use `.ipv4()`/`.ipv6()` variants. | No |
-| [no-promise-schema](docs/rules/no-promise-schema.md) | Disallow `z.promise()`. Await before parsing. | No |
+| [no-deprecated-string-format](docs/rules/no-deprecated-string-format.md) | Disallow `z.string().email()` etc. Use `z.email()` instead. | ✅ Yes |
+| [no-record-single-arg](docs/rules/no-record-single-arg.md) | Require `z.record(keySchema, valueSchema)` with two arguments. | ❌ No |
+| [no-deprecated-error-params](docs/rules/no-deprecated-error-params.md) | Disallow `invalid_type_error`/`required_error`. Use `error` param. | ✅ Yes |
+| [no-deprecated-format-methods](docs/rules/no-deprecated-format-methods.md) | Disallow `.format()`/`.flatten()` on ZodError. Use `z.treeifyError()`. | ❌ No |
+| [no-merge-method](docs/rules/no-merge-method.md) | Disallow `.merge()`. Use `.extend()` instead. | ❌ No |
+| [no-superrefine](docs/rules/no-superrefine.md) | Disallow `.superRefine()`. Use `.check()` instead. | ✅ Yes |
+| [no-errors-property](docs/rules/no-errors-property.md) | Disallow `error.errors`. Use `error.issues` instead. | ✅ Yes |
+| [no-deprecated-object-methods](docs/rules/no-deprecated-object-methods.md) | Disallow `.strict()`/`.passthrough()`/`.strip()`. Use top-level functions. | ❌ No |
+| [no-native-enum](docs/rules/no-native-enum.md) | Disallow `z.nativeEnum()`. Use `z.enum()` instead. | ❌ No |
+| [no-deep-partial](docs/rules/no-deep-partial.md) | Disallow `.deepPartial()` (removed in v4). | ❌ No |
+| [no-deprecated-ip-methods](docs/rules/no-deprecated-ip-methods.md) | Disallow `.ip()`/`.cidr()`. Use `.ipv4()`/`.ipv6()` variants. | ❌ No |
+| [no-promise-schema](docs/rules/no-promise-schema.md) | Disallow `z.promise()`. Await before parsing. | ❌ No |
 
 ### Best Practices (severity: warn)
 
@@ -87,9 +88,62 @@ These rules enforce Zod v4 best practices for optimal code quality.
 
 | Rule | Description | Fixable |
 |------|-------------|---------|
-| [prefer-safeParse](docs/rules/prefer-safeParse.md) | Prefer `.safeParse()` over `.parse()` for explicit error handling. | Yes |
-| [no-schema-in-render](docs/rules/no-schema-in-render.md) | Disallow creating schemas inside functions/components. | No |
-| [prefer-error-param](docs/rules/prefer-error-param.md) | Prefer `error` param over deprecated `message` param. | Yes |
+| [prefer-safeParse](docs/rules/prefer-safeParse.md) | Prefer `.safeParse()` over `.parse()` for explicit error handling. | ✅ Yes |
+| [no-schema-in-render](docs/rules/no-schema-in-render.md) | Disallow creating schemas inside functions/components. **React-aware**: allows `useMemo`/`useCallback`. | ❌ No |
+| [prefer-error-param](docs/rules/prefer-error-param.md) | Prefer `error` param over deprecated `message` param. | ✅ Yes |
+
+## React Integration
+
+### Schema Creation in Components
+
+The `no-schema-in-render` rule is React-aware and recognizes memoization patterns:
+
+```tsx
+// ❌ Bad - Schema recreated every render
+const MyComponent = () => {
+  const schema = z.object({ name: z.string() })  // Error!
+  return <Form schema={schema} />
+}
+
+// ✅ Good - Schema at module level
+const schema = z.object({ name: z.string() })
+const MyComponent = () => {
+  return <Form schema={schema} />
+}
+
+// ✅ Good - Schema memoized with useMemo (for translated schemas)
+const MyComponent = () => {
+  const t = useTranslations()
+  const schema = useMemo(() => z.object({
+    email: z.email(t('invalidEmail')),
+  }), [t])
+  return <Form schema={schema} />
+}
+
+// ✅ Good - Factory function with useMemo
+const createSchema = (t) => z.object({ email: z.email(t('error')) })
+const MyComponent = () => {
+  const t = useTranslations()
+  const schema = useMemo(() => createSchema(t), [t])
+  return <Form schema={schema} />
+}
+```
+
+### TypeScript Workaround for `.check()` ctx.addIssue
+
+When using `.check()`, TypeScript may incorrectly flag `ctx.addIssue()` calls:
+
+```typescript
+// If you see: @typescript-eslint/no-unsafe-call on ctx.addIssue()
+// Add this comment to suppress the false positive:
+.check((ctx) => {
+  const { value: data } = ctx;
+  if (!data.name) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call -- Zod v4 ctx.addIssue is type-safe at runtime
+    ctx.addIssue({ code: 'custom', message: 'Name required' });
+  }
+})
+```
 
 ## Migration Guide
 
@@ -124,9 +178,11 @@ z.record(z.string(), z.string())
 ```javascript
 // Before (deprecated)
 z.string({ invalid_type_error: "Must be string", required_error: "Required" })
+z.string().refine(fn, { message: "Error" })
 
 // After (v4)
 z.string({ error: "Must be string" })
+z.string().refine(fn, { error: "Error" })
 // Or with function
 z.string({ error: (iss) => `Error: ${iss.code}` })
 ```
@@ -164,7 +220,7 @@ schema1.extend(schema2.shape)
 z.object({ ...schema1.shape, ...schema2.shape })
 ```
 
-#### 7. Super Refine
+#### 7. Super Refine → Check
 
 ```javascript
 // Before (deprecated)
@@ -175,6 +231,14 @@ schema.superRefine((val, ctx) => {
 })
 
 // After (v4)
+schema.check((ctx) => {
+  const { value: val } = ctx;
+  if (!isValid(val)) {
+    ctx.addIssue({ code: "custom", message: "Invalid" })
+  }
+})
+
+// Or for simple cases
 schema.check((val) => isValid(val) || "Invalid")
 ```
 
@@ -235,6 +299,22 @@ schema.partial()  // shallow only
 // For deep partial, manually create nested partial schemas
 ```
 
+## Changelog
+
+### v0.2.0 (2025-12-16)
+
+**New Features:**
+- `no-superrefine`: Now has **auto-fix** support! Transforms `.superRefine((data, ctx) => {...})` to `.check((ctx) => { const { value: data } = ctx; ...})`
+- `no-schema-in-render`: Now **recognizes `useMemo` and `useCallback`** - schemas inside memoized callbacks are allowed
+- Improved error messages with migration examples
+
+**Bug Fixes:**
+- Fixed false positives in `no-schema-in-render` when using React memoization hooks
+
+### v0.1.1 (2025-12-15)
+
+- Initial release with 15 rules (12 breaking changes + 3 best practices)
+
 ## Contributing
 
 Contributions are welcome! Please read our contributing guidelines before submitting a PR.

package/dist/index.cjs

@@ -11685,16 +11685,6 @@ function isZodChainCall(node) {
   }
   return false;
 }
-function isInsideFunction(node) {
-  let current = node.parent;
-  while (current) {
-    if (current.type === "FunctionDeclaration" || current.type === "FunctionExpression" || current.type === "ArrowFunctionExpression") {
-      return true;
-    }
-    current = current.parent;
-  }
-  return false;
-}
 function isLikelyZodSchemaCall(node) {
   if (node.callee.type !== "MemberExpression") return false;
   if (isZodChainCall(node)) return true;
@@ -11707,6 +11697,27 @@ function isLikelyZodSchemaCall(node) {
   }
   return false;
 }
+var REACT_MEMO_HOOKS = ["useMemo", "useCallback"];
+function isInsideMemoizedCallback(node) {
+  if (node.type !== "ArrowFunctionExpression" && node.type !== "FunctionExpression") {
+    return false;
+  }
+  const parent = node.parent;
+  if (!parent || parent.type !== "CallExpression") {
+    return false;
+  }
+  if (parent.arguments[0] !== node) {
+    return false;
+  }
+  const callee = parent.callee;
+  if (callee.type === "Identifier") {
+    return REACT_MEMO_HOOKS.includes(callee.name);
+  }
+  if (callee.type === "MemberExpression" && callee.property.type === "Identifier") {
+    return REACT_MEMO_HOOKS.includes(callee.property.name);
+  }
+  return false;
+}
 
 // src/rules/no-deprecated-string-format.ts
 var noDeprecatedStringFormat = createRule({
@@ -11962,9 +11973,10 @@ var noSuperRefine = createRule({
     docs: {
       description: "Disallow deprecated .superRefine() method in favor of .check()"
     },
+    fixable: "code",
     schema: [],
     messages: {
-      deprecatedSuperRefine: ".superRefine() is deprecated in Zod v4. Use .check() instead for custom validations."
+      deprecatedSuperRefine: ".superRefine() is deprecated in Zod v4. Use .check() instead.\n\nMigration pattern:\n// Before (Zod v3):\n.superRefine((data, ctx) => {\n  ctx.addIssue({ code: 'custom', message: '...' });\n})\n\n// After (Zod v4):\n.check((ctx) => {\n  const { value: data } = ctx;\n  ctx.addIssue({ code: 'custom', message: '...' });\n})"
     }
   },
   defaultOptions: [],
@@ -11975,9 +11987,60 @@ var noSuperRefine = createRule({
         const methodName = getMethodName(node.callee);
         if (methodName !== "superRefine") return;
         if (!isLikelyZodSchemaCall(node)) return;
+        const callback = node.arguments[0];
         context.report({
           node,
-          messageId: "deprecatedSuperRefine"
+          messageId: "deprecatedSuperRefine",
+          fix(fixer) {
+            if (!callback) return null;
+            const memberExpr = node.callee;
+            const property = memberExpr.property;
+            if (property.type !== "Identifier") return null;
+            if (callback.type !== "ArrowFunctionExpression" && callback.type !== "FunctionExpression") {
+              return null;
+            }
+            const params = callback.params;
+            if (params.length === 0) {
+              return fixer.replaceText(property, "check");
+            }
+            const sourceCode = context.sourceCode;
+            const firstParam = params[0];
+            const secondParam = params[1];
+            if (params.length === 1 && firstParam) {
+              const paramName = sourceCode.getText(firstParam);
+              if (paramName === "ctx" || paramName === "context") {
+                return fixer.replaceText(property, "check");
+              }
+              if (callback.body.type === "BlockStatement") {
+                const bodyStart = callback.body.range[0] + 1;
+                const dataDecl = ` const { value: ${paramName} } = ctx;`;
+                return [
+                  fixer.replaceText(property, "check"),
+                  fixer.replaceText(firstParam, "ctx"),
+                  fixer.insertTextAfterRange([bodyStart, bodyStart], dataDecl)
+                ];
+              }
+              return fixer.replaceText(property, "check");
+            }
+            if (params.length >= 2 && firstParam && secondParam) {
+              const dataParamName = sourceCode.getText(firstParam);
+              const ctxParamName = sourceCode.getText(secondParam);
+              if (callback.body.type === "BlockStatement") {
+                const bodyStart = callback.body.range[0] + 1;
+                const useCtxName = ctxParamName === "ctx" ? "ctx" : ctxParamName;
+                const dataDecl = ` const { value: ${dataParamName} } = ${useCtxName};`;
+                const paramsStart = firstParam.range[0];
+                const paramsEnd = secondParam.range[1];
+                return [
+                  fixer.replaceText(property, "check"),
+                  fixer.replaceTextRange([paramsStart, paramsEnd], useCtxName),
+                  fixer.insertTextAfterRange([bodyStart, bodyStart], dataDecl)
+                ];
+              }
+              return fixer.replaceText(property, "check");
+            }
+            return fixer.replaceText(property, "check");
+          }
         });
       }
     };
@@ -12270,7 +12333,7 @@ var noSchemaInRender = createRule({
     },
     schema: [],
     messages: {
-      schemaInRender: "Avoid creating Zod schemas inside functions or React components. Schemas are recreated on every render/call, causing performance issues. Move the schema to module scope or use useMemo."
+      schemaInRender: "Avoid creating Zod schemas inside functions or React components. Schemas are recreated on every render/call, causing performance issues. Move the schema to module scope, use useMemo(() => z.object({...}), [deps]), or extract to a factory function called with useMemo."
     }
   },
   defaultOptions: [],
@@ -12315,7 +12378,7 @@ var noSchemaInRender = createRule({
           "custom",
           "preprocess",
           "coerce",
-          // Top-level format functions
+          // Top-level format functions (Zod v4)
           "email",
           "url",
           "uuid",
@@ -12325,13 +12388,28 @@ var noSchemaInRender = createRule({
           "ip",
           "ipv4",
           "ipv6",
+          "cidr",
+          "cidrv4",
+          "cidrv6",
           "datetime",
-          "base64"
+          "base64",
+          "base64url",
+          "jwt",
+          "emoji",
+          "nanoid",
+          "ascii",
+          "utf8",
+          "hexadecimal",
+          "e164",
+          "bic",
+          "iban",
+          "time",
+          "duration"
         ];
         const object = node.callee.object;
         if (object.type !== "Identifier" || object.name !== "z") return;
         if (!schemaCreatingMethods.includes(methodName)) return;
-        if (!isInsideFunction(node)) return;
+        if (!isInsideFunctionButNotMemoized(node)) return;
         context.report({
           node,
           messageId: "schemaInRender"
@@ -12340,6 +12418,52 @@ var noSchemaInRender = createRule({
     };
   }
 });
+function isInsideFunctionButNotMemoized(node) {
+  let current = node.parent;
+  const functionStack = [];
+  while (current) {
+    if (current.type === "FunctionDeclaration" || current.type === "FunctionExpression" || current.type === "ArrowFunctionExpression") {
+      functionStack.push(current);
+    }
+    current = current.parent;
+  }
+  if (functionStack.length === 0) {
+    return false;
+  }
+  const innermostFunction = functionStack[0];
+  if (isInsideMemoizedCallback(innermostFunction)) {
+    return false;
+  }
+  for (let i = 1; i < functionStack.length; i++) {
+    const func = functionStack[i];
+    if (func && isInsideMemoizedCallback(func)) {
+      return true;
+    }
+  }
+  const outermostFunction = functionStack[functionStack.length - 1];
+  if (isModuleLevelFactoryFunction(outermostFunction)) {
+    return false;
+  }
+  return true;
+}
+function isModuleLevelFactoryFunction(node) {
+  if (node.type !== "ArrowFunctionExpression") {
+    return false;
+  }
+  const arrowFunc = node;
+  if (arrowFunc.body.type === "BlockStatement") {
+    return false;
+  }
+  const parent = node.parent;
+  if (parent?.type === "VariableDeclarator") {
+    const varDecl = parent.parent;
+    if (varDecl?.type === "VariableDeclaration") {
+      const grandParent = varDecl.parent;
+      return grandParent?.type === "Program" || grandParent?.type === "ExportNamedDeclaration";
+    }
+  }
+  return false;
+}
 
 // src/rules/prefer-error-param.ts
 var preferErrorParam = createRule({
@@ -12384,7 +12508,7 @@ var preferErrorParam = createRule({
 // src/index.ts
 var meta = {
   name: "eslint-plugin-zod-v4",
-  version: "0.1.0"
+  version: "0.1.1"
 };
 var rules = {
   // Breaking Changes