eslint-plugin-zod 4.1.0 → 4.2.1

package/README.md

@@ -42,6 +42,7 @@ Find out more about [Oxlint's `jsPLugins`](https://oxc.rs/docs/guide/usage/linte
 | [consistent-schema-var-name](docs/rules/consistent-schema-var-name.md)                           | Enforce a consistent naming convention for Zod schema variables                                                                | ✅  |     |     |     |
 | [no-any-schema](docs/rules/no-any-schema.md)                                                     | Disallow usage of `z.any()` in Zod schemas                                                                                     | ✅  |     | 💡  |     |
 | [no-empty-custom-schema](docs/rules/no-empty-custom-schema.md)                                   | Disallow usage of `z.custom()` without arguments                                                                               | ✅  |     |     |     |
+| [no-native-enum](docs/rules/no-native-enum.md)                                                   | Disallow deprecated `z.nativeEnum()` in favor of `z.enum()`.                                                                   | ✅  | 🔧  |     |     |
 | [no-number-schema-with-finite](docs/rules/no-number-schema-with-finite.md)                       | Disallow deprecated `z.number().finite()`. In Zod 4+ number schemas do not allow infinite values by default, so it is a no-op. | ✅  | 🔧  |     |     |
 | [no-number-schema-with-int](docs/rules/no-number-schema-with-int.md)                             | Disallow usage of `z.number().int()` as it is considered legacy                                                                | ✅  | 🔧  |     |     |
 | [no-number-schema-with-is-finite](docs/rules/no-number-schema-with-is-finite.md)                 | Disallow using deprecated `isFinite` on a Zod number schema; in v4+ it is always `true`.                                       | ✅  |     |     |     |

package/dist/index.cjs

@@ -7,6 +7,7 @@ const require_consistent_schema_output_type_style = require("./rules/consistent-
 const require_consistent_schema_var_name = require("./rules/consistent-schema-var-name.cjs");
 const require_no_any_schema = require("./rules/no-any-schema.cjs");
 const require_no_empty_custom_schema = require("./rules/no-empty-custom-schema.cjs");
+const require_no_native_enum = require("./rules/no-native-enum.cjs");
 const require_no_number_schema_with_finite = require("./rules/no-number-schema-with-finite.cjs");
 const require_no_number_schema_with_int = require("./rules/no-number-schema-with-int.cjs");
 const require_no_number_schema_with_is_finite = require("./rules/no-number-schema-with-is-finite.cjs");
@@ -42,6 +43,7 @@ const eslintPluginZod = {
 		"consistent-schema-output-type-style": require_consistent_schema_output_type_style.consistentSchemaOutputTypeStyle,
 		"no-any-schema": require_no_any_schema.noAnySchema,
 		"no-empty-custom-schema": require_no_empty_custom_schema.noEmptyCustomSchema,
+		"no-native-enum": require_no_native_enum.noNativeEnum,
 		"no-number-schema-with-finite": require_no_number_schema_with_finite.noNumberSchemaWithFinite,
 		"no-number-schema-with-int": require_no_number_schema_with_int.noNumberSchemaWithInt,
 		"no-number-schema-with-is-finite": require_no_number_schema_with_is_finite.noNumberSchemaWithIsFinite,
@@ -74,6 +76,7 @@ const recommendedConfig = {
 		"zod/consistent-schema-var-name": "error",
 		"zod/no-any-schema": "error",
 		"zod/no-empty-custom-schema": "error",
+		"zod/no-native-enum": "error",
 		"zod/no-number-schema-with-finite": "error",
 		"zod/no-number-schema-with-int": "error",
 		"zod/no-number-schema-with-is-finite": "error",

package/dist/index.mjs

@@ -7,6 +7,7 @@ import { consistentSchemaOutputTypeStyle } from "./rules/consistent-schema-outpu
 import { consistentSchemaVarName } from "./rules/consistent-schema-var-name.mjs";
 import { noAnySchema } from "./rules/no-any-schema.mjs";
 import { noEmptyCustomSchema } from "./rules/no-empty-custom-schema.mjs";
+import { noNativeEnum } from "./rules/no-native-enum.mjs";
 import { noNumberSchemaWithFinite } from "./rules/no-number-schema-with-finite.mjs";
 import { noNumberSchemaWithInt } from "./rules/no-number-schema-with-int.mjs";
 import { noNumberSchemaWithIsFinite } from "./rules/no-number-schema-with-is-finite.mjs";
@@ -42,6 +43,7 @@ const eslintPluginZod = {
 		"consistent-schema-output-type-style": consistentSchemaOutputTypeStyle,
 		"no-any-schema": noAnySchema,
 		"no-empty-custom-schema": noEmptyCustomSchema,
+		"no-native-enum": noNativeEnum,
 		"no-number-schema-with-finite": noNumberSchemaWithFinite,
 		"no-number-schema-with-int": noNumberSchemaWithInt,
 		"no-number-schema-with-is-finite": noNumberSchemaWithIsFinite,
@@ -74,6 +76,7 @@ const recommendedConfig = {
 		"zod/consistent-schema-var-name": "error",
 		"zod/no-any-schema": "error",
 		"zod/no-empty-custom-schema": "error",
+		"zod/no-native-enum": "error",
 		"zod/no-number-schema-with-finite": "error",
 		"zod/no-number-schema-with-int": "error",
 		"zod/no-number-schema-with-is-finite": "error",

package/dist/rules/array-style.cjs

@@ -32,9 +32,9 @@ const arrayStyle = require_create_plugin_rule.createZodPluginRule({
 		return {
 			ImportDeclaration: importDeclarationListener,
 			CallExpression(node) {
-				const zodSchema = detectZodSchemaRootNode(node);
-				if (!zodSchema) return;
-				const { schemaDecl, schemaType } = zodSchema;
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (!zodSchemaMeta) return;
+				const { schemaDecl, schemaType } = zodSchemaMeta;
 				if (style === "method") {
 					if (schemaType === "array") {
 						if (schemaDecl === "namespace") {

package/dist/rules/array-style.mjs

@@ -31,9 +31,9 @@ const arrayStyle = createZodPluginRule({
 		return {
 			ImportDeclaration: importDeclarationListener,
 			CallExpression(node) {
-				const zodSchema = detectZodSchemaRootNode(node);
-				if (!zodSchema) return;
-				const { schemaDecl, schemaType } = zodSchema;
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (!zodSchemaMeta) return;
+				const { schemaDecl, schemaType } = zodSchemaMeta;
 				if (style === "method") {
 					if (schemaType === "array") {
 						if (schemaDecl === "namespace") {

package/dist/rules/no-native-enum.cjs

@@ -0,0 +1,38 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+let _eslint_zod_utils = require("@eslint-zod/utils");
+let _typescript_eslint_utils = require("@typescript-eslint/utils");
+//#region src/rules/no-native-enum.ts
+const { trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)(_eslint_zod_utils.zodImportScope);
+const noNativeEnum = require_create_plugin_rule.createZodPluginRule({
+	name: "no-native-enum",
+	meta: {
+		type: "problem",
+		fixable: "code",
+		docs: { description: "Disallow deprecated `z.nativeEnum()` in favor of `z.enum()`." },
+		messages: { useEnum: "`z.nativeEnum()` is deprecated in Zod 4. Use `z.enum()` instead." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (zodSchemaMeta?.schemaType !== "nativeEnum") return;
+				const [{ node: rootMethodNode }] = collectZodChainMethods(zodSchemaMeta.node);
+				context.report({
+					node,
+					messageId: "useEnum",
+					fix(fixer) {
+						if (rootMethodNode.callee.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return null;
+						return fixer.replaceText(rootMethodNode.callee.property, "enum");
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+exports.noNativeEnum = noNativeEnum;

package/dist/rules/no-native-enum.mjs

@@ -0,0 +1,37 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack, zodImportScope } from "@eslint-zod/utils";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region src/rules/no-native-enum.ts
+const { trackZodSchemaImports } = createZodSchemaImportTrack(zodImportScope);
+const noNativeEnum = createZodPluginRule({
+	name: "no-native-enum",
+	meta: {
+		type: "problem",
+		fixable: "code",
+		docs: { description: "Disallow deprecated `z.nativeEnum()` in favor of `z.enum()`." },
+		messages: { useEnum: "`z.nativeEnum()` is deprecated in Zod 4. Use `z.enum()` instead." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (zodSchemaMeta?.schemaType !== "nativeEnum") return;
+				const [{ node: rootMethodNode }] = collectZodChainMethods(zodSchemaMeta.node);
+				context.report({
+					node,
+					messageId: "useEnum",
+					fix(fixer) {
+						if (rootMethodNode.callee.type !== AST_NODE_TYPES.MemberExpression) return null;
+						return fixer.replaceText(rootMethodNode.callee.property, "enum");
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { noNativeEnum };

package/dist/rules/no-number-schema-with-int.cjs

@@ -25,17 +25,11 @@ const noNumberSchemaWithInt = require_create_plugin_rule.createZodPluginRule({
 				const intIndex = methods.findIndex((m) => m.name === "int");
 				if (intIndex === -1) return;
 				const numberIndex = methods.findIndex((m) => m.name === "number");
-				if (zodSchemaMeta.schemaDecl === "named") {
-					context.report({
-						node,
-						messageId: "removeNumber"
-					});
-					return;
-				}
 				context.report({
 					node,
 					messageId: "removeNumber",
 					fix(fixer) {
+						if (zodSchemaMeta.schemaDecl === "named") return null;
 						return (0, _eslint_zod_utils.buildZodChainReplacementFix)({
 							sourceCode,
 							fixer,

package/dist/rules/no-number-schema-with-int.mjs

@@ -24,17 +24,11 @@ const noNumberSchemaWithInt = createZodPluginRule({
 				const intIndex = methods.findIndex((m) => m.name === "int");
 				if (intIndex === -1) return;
 				const numberIndex = methods.findIndex((m) => m.name === "number");
-				if (zodSchemaMeta.schemaDecl === "named") {
-					context.report({
-						node,
-						messageId: "removeNumber"
-					});
-					return;
-				}
 				context.report({
 					node,
 					messageId: "removeNumber",
 					fix(fixer) {
+						if (zodSchemaMeta.schemaDecl === "named") return null;
 						return buildZodChainReplacementFix({
 							sourceCode,
 							fixer,

package/dist/rules/no-number-schema-with-safe.cjs

@@ -25,17 +25,11 @@ const noNumberSchemaWithSafe = require_create_plugin_rule.createZodPluginRule({
 				const safeIndex = methods.findIndex((m) => m.name === "safe" && m.node === node);
 				if (safeIndex === -1) return;
 				const numberIndex = methods.findIndex((m) => m.name === "number");
-				if (zodSchemaMeta.schemaDecl === "named") {
-					context.report({
-						node,
-						messageId: "useInt"
-					});
-					return;
-				}
 				context.report({
 					node,
 					messageId: "useInt",
 					fix(fixer) {
+						if (zodSchemaMeta.schemaDecl === "named") return null;
 						return (0, _eslint_zod_utils.buildZodChainReplacementFix)({
 							sourceCode,
 							fixer,

package/dist/rules/no-number-schema-with-safe.mjs

@@ -24,17 +24,11 @@ const noNumberSchemaWithSafe = createZodPluginRule({
 				const safeIndex = methods.findIndex((m) => m.name === "safe" && m.node === node);
 				if (safeIndex === -1) return;
 				const numberIndex = methods.findIndex((m) => m.name === "number");
-				if (zodSchemaMeta.schemaDecl === "named") {
-					context.report({
-						node,
-						messageId: "useInt"
-					});
-					return;
-				}
 				context.report({
 					node,
 					messageId: "useInt",
 					fix(fixer) {
+						if (zodSchemaMeta.schemaDecl === "named") return null;
 						return buildZodChainReplacementFix({
 							sourceCode,
 							fixer,

package/dist/rules/no-string-schema-with-uuid.cjs

@@ -29,17 +29,11 @@ const noStringSchemaWithUuid = require_create_plugin_rule.createZodPluginRule({
 				const uuidIndex = methods.findIndex((m) => m.name === "uuid");
 				if (uuidIndex === -1) return;
 				const stringIndex = methods.findIndex((m) => m.name === "string");
-				if (zodSchemaMeta.schemaDecl === "named") {
-					context.report({
-						node,
-						messageId: "useUuid"
-					});
-					return;
-				}
 				context.report({
 					node,
 					messageId: "useUuid",
 					fix(fixer) {
+						if (zodSchemaMeta.schemaDecl === "named") return null;
 						return (0, _eslint_zod_utils.buildZodChainReplacementFix)({
 							sourceCode,
 							fixer,

package/dist/rules/no-string-schema-with-uuid.mjs

@@ -28,17 +28,11 @@ const noStringSchemaWithUuid = createZodPluginRule({
 				const uuidIndex = methods.findIndex((m) => m.name === "uuid");
 				if (uuidIndex === -1) return;
 				const stringIndex = methods.findIndex((m) => m.name === "string");
-				if (zodSchemaMeta.schemaDecl === "named") {
-					context.report({
-						node,
-						messageId: "useUuid"
-					});
-					return;
-				}
 				context.report({
 					node,
 					messageId: "useUuid",
 					fix(fixer) {
+						if (zodSchemaMeta.schemaDecl === "named") return null;
 						return buildZodChainReplacementFix({
 							sourceCode,
 							fixer,

package/dist/rules/prefer-enum-over-literal-union.cjs

@@ -19,9 +19,9 @@ const preferEnumOverLiteralUnion = require_create_plugin_rule.createZodPluginRul
 		return {
 			ImportDeclaration: importDeclarationListener,
 			CallExpression(node) {
-				const zodSchema = detectZodSchemaRootNode(node);
-				if (zodSchema?.schemaType !== "union") return;
-				const union = collectZodChainMethods(zodSchema.node).find((it) => it.name === "union");
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (zodSchemaMeta?.schemaType !== "union") return;
+				const union = collectZodChainMethods(zodSchemaMeta.node).find((it) => it.name === "union");
 				if (!union) return;
 				const unionNode = union.node;
 				const unionArgument = unionNode.arguments.at(0);
@@ -39,17 +39,11 @@ const preferEnumOverLiteralUnion = require_create_plugin_rule.createZodPluginRul
 					return null;
 				});
 				if (zodLiteralStrings.some((it) => it === null)) return;
-				if (zodSchema.schemaDecl === "named") {
-					context.report({
-						node,
-						messageId: "useEnum"
-					});
-					return;
-				}
 				context.report({
 					node,
 					messageId: "useEnum",
 					fix(fixer) {
+						if (zodSchemaMeta.schemaDecl === "named") return null;
 						return [fixer.replaceText(unionNode.callee.property, "enum"), fixer.replaceText(unionNode.arguments[0], `[${zodLiteralStrings.join(", ")}]`)];
 					}
 				});

package/dist/rules/prefer-enum-over-literal-union.mjs

@@ -18,9 +18,9 @@ const preferEnumOverLiteralUnion = createZodPluginRule({
 		return {
 			ImportDeclaration: importDeclarationListener,
 			CallExpression(node) {
-				const zodSchema = detectZodSchemaRootNode(node);
-				if (zodSchema?.schemaType !== "union") return;
-				const union = collectZodChainMethods(zodSchema.node).find((it) => it.name === "union");
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (zodSchemaMeta?.schemaType !== "union") return;
+				const union = collectZodChainMethods(zodSchemaMeta.node).find((it) => it.name === "union");
 				if (!union) return;
 				const unionNode = union.node;
 				const unionArgument = unionNode.arguments.at(0);
@@ -38,17 +38,11 @@ const preferEnumOverLiteralUnion = createZodPluginRule({
 					return null;
 				});
 				if (zodLiteralStrings.some((it) => it === null)) return;
-				if (zodSchema.schemaDecl === "named") {
-					context.report({
-						node,
-						messageId: "useEnum"
-					});
-					return;
-				}
 				context.report({
 					node,
 					messageId: "useEnum",
 					fix(fixer) {
+						if (zodSchemaMeta.schemaDecl === "named") return null;
 						return [fixer.replaceText(unionNode.callee.property, "enum"), fixer.replaceText(unionNode.arguments[0], `[${zodLiteralStrings.join(", ")}]`)];
 					}
 				});

package/dist/rules/prefer-string-schema-with-trim.cjs

@@ -26,17 +26,11 @@ const preferStringSchemaWithTrim = require_create_plugin_rule.createZodPluginRul
 				})) return;
 				const methods = collectZodChainMethods(zodSchemaMeta.node);
 				if (methods.some((it) => it.name === "trim")) return;
-				if (zodSchemaMeta.schemaDecl === "named") {
-					context.report({
-						node,
-						messageId: "addTrim"
-					});
-					return;
-				}
 				context.report({
 					node,
 					messageId: "addTrim",
 					fix(fixer) {
+						if (zodSchemaMeta.schemaDecl === "named") return null;
 						const lastMethod = methods.at(0);
 						return fixer.insertTextAfter(lastMethod.node, ".trim()");
 					}

package/dist/rules/prefer-string-schema-with-trim.mjs

@@ -25,17 +25,11 @@ const preferStringSchemaWithTrim = createZodPluginRule({
 				})) return;
 				const methods = collectZodChainMethods(zodSchemaMeta.node);
 				if (methods.some((it) => it.name === "trim")) return;
-				if (zodSchemaMeta.schemaDecl === "named") {
-					context.report({
-						node,
-						messageId: "addTrim"
-					});
-					return;
-				}
 				context.report({
 					node,
 					messageId: "addTrim",
 					fix(fixer) {
+						if (zodSchemaMeta.schemaDecl === "named") return null;
 						const lastMethod = methods.at(0);
 						return fixer.insertTextAfter(lastMethod.node, ".trim()");
 					}

package/dist/rules/prefer-top-level-string-formats.cjs

@@ -156,17 +156,6 @@ const preferTopLevelStringFormats = require_create_plugin_rule.createZodPluginRu
 				if (!formatMethod) return;
 				if (!isTopLevelStringFormatMethodName(formatMethod.name)) return;
 				const { replacementMethodName, sourceMethodName } = TOP_LEVEL_STRING_FORMATS_BY_SOURCE[formatMethod.name];
-				if (zodSchemaMeta.schemaDecl === "named") {
-					context.report({
-						node,
-						messageId: "preferTopLevelStringFormat",
-						data: {
-							replacementMethod: replacementMethodName,
-							sourceMethod: sourceMethodName
-						}
-					});
-					return;
-				}
 				context.report({
 					node,
 					messageId: "preferTopLevelStringFormat",
@@ -175,6 +164,7 @@ const preferTopLevelStringFormats = require_create_plugin_rule.createZodPluginRu
 						sourceMethod: sourceMethodName
 					},
 					fix(fixer) {
+						if (zodSchemaMeta.schemaDecl === "named") return null;
 						return (0, _eslint_zod_utils.buildZodChainReplacementFix)({
 							sourceCode,
 							fixer,

package/dist/rules/prefer-top-level-string-formats.mjs

@@ -155,17 +155,6 @@ const preferTopLevelStringFormats = createZodPluginRule({
 				if (!formatMethod) return;
 				if (!isTopLevelStringFormatMethodName(formatMethod.name)) return;
 				const { replacementMethodName, sourceMethodName } = TOP_LEVEL_STRING_FORMATS_BY_SOURCE[formatMethod.name];
-				if (zodSchemaMeta.schemaDecl === "named") {
-					context.report({
-						node,
-						messageId: "preferTopLevelStringFormat",
-						data: {
-							replacementMethod: replacementMethodName,
-							sourceMethod: sourceMethodName
-						}
-					});
-					return;
-				}
 				context.report({
 					node,
 					messageId: "preferTopLevelStringFormat",
@@ -174,6 +163,7 @@ const preferTopLevelStringFormats = createZodPluginRule({
 						sourceMethod: sourceMethodName
 					},
 					fix(fixer) {
+						if (zodSchemaMeta.schemaDecl === "named") return null;
 						return buildZodChainReplacementFix({
 							sourceCode,
 							fixer,

package/dist/rules/prefer-trim-before-string-length-checks.cjs

@@ -35,17 +35,11 @@ const preferTrimBeforeStringLengthChecks = require_create_plugin_rule.createZodP
 				const firstLengthCheckIndex = methods.findIndex((m) => LENGTH_CHECK_METHODS.includes(m.name));
 				if (firstLengthCheckIndex === -1) return;
 				if (trimIndex < firstLengthCheckIndex) return;
-				if (zodSchemaMeta.schemaDecl === "named") {
-					context.report({
-						node,
-						messageId: "trimBeforeLengthCheck"
-					});
-					return;
-				}
 				context.report({
 					node,
 					messageId: "trimBeforeLengthCheck",
 					fix(fixer) {
+						if (zodSchemaMeta.schemaDecl === "named") return null;
 						const stringMethodNode = methods[0].node;
 						const trimMethodNode = methods[trimIndex].node;
 						const trimCallee = trimMethodNode.callee;

package/dist/rules/prefer-trim-before-string-length-checks.mjs

@@ -34,17 +34,11 @@ const preferTrimBeforeStringLengthChecks = createZodPluginRule({
 				const firstLengthCheckIndex = methods.findIndex((m) => LENGTH_CHECK_METHODS.includes(m.name));
 				if (firstLengthCheckIndex === -1) return;
 				if (trimIndex < firstLengthCheckIndex) return;
-				if (zodSchemaMeta.schemaDecl === "named") {
-					context.report({
-						node,
-						messageId: "trimBeforeLengthCheck"
-					});
-					return;
-				}
 				context.report({
 					node,
 					messageId: "trimBeforeLengthCheck",
 					fix(fixer) {
+						if (zodSchemaMeta.schemaDecl === "named") return null;
 						const stringMethodNode = methods[0].node;
 						const trimMethodNode = methods[trimIndex].node;
 						const trimCallee = trimMethodNode.callee;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-zod",
-  "version": "4.1.0",
+  "version": "4.2.1",
   "type": "module",
   "description": "ESLint plugin that adds custom linting rules to enforce best practices when using Zod",
   "engines": {
@@ -43,7 +43,7 @@
   "dependencies": {
     "@typescript-eslint/utils": "^8.57.0",
     "esquery": "^1.6.0",
-    "@eslint-zod/utils": "1.0.1"
+    "@eslint-zod/utils": "1.1.0"
   },
   "peerDependencies": {
     "eslint": "^9 || ^10",