eslint-plugin-zod 4.3.0 → 4.5.0

package/README.md

@@ -50,6 +50,8 @@ Find out more about [Oxlint's `jsPLugins`](https://oxc.rs/docs/guide/usage/linte
 | [no-number-schema-with-safe](docs/rules/no-number-schema-with-safe.md)                           | Disallow deprecated `z.number().safe()`. Use `z.int()`; `.safe()` is now identical to `.int()`.                                | ✅  | 🔧  |     |     |
 | [no-number-schema-with-step](docs/rules/no-number-schema-with-step.md)                           | Disallow deprecated `z.number().step()`. Use `.multipleOf()` instead.                                                          | ✅  | 🔧  |     |     |
 | [no-optional-and-default-together](docs/rules/no-optional-and-default-together.md)               | Disallow using both `.optional()` and `.default()` on the same Zod schema                                                      | ✅  | 🔧  |     |     |
+| [no-promise-schema](docs/rules/no-promise-schema.md)                                             | Disallow deprecated `z.promise()` schemas.                                                                                     | ✅  |     |     |     |
+| [no-schema-with-is-nullable](docs/rules/no-schema-with-is-nullable.md)                           | Disallow deprecated `.isNullable()` on a Zod schema; use `safeParse(null).success` instead.                                    | ✅  |     |     |     |
 | [no-schema-with-is-optional](docs/rules/no-schema-with-is-optional.md)                           | Disallow deprecated `.isOptional()` on a Zod schema; use `safeParse(undefined).success` instead.                               | ✅  |     |     |     |
 | [no-string-schema-with-uuid](docs/rules/no-string-schema-with-uuid.md)                           | Disallow usage of `z.string().uuid()` in favor of the dedicated `z.uuid()` schema                                              | ✅  | 🔧  |     | ❌  |
 | [no-throw-in-refine](docs/rules/no-throw-in-refine.md)                                           | Disallow throwing errors directly inside Zod refine callbacks                                                                  | ✅  |     |     |     |

package/dist/index.cjs

@@ -15,6 +15,8 @@ const require_no_number_schema_with_is_int = require("./rules/no-number-schema-w
 const require_no_number_schema_with_safe = require("./rules/no-number-schema-with-safe.cjs");
 const require_no_number_schema_with_step = require("./rules/no-number-schema-with-step.cjs");
 const require_no_optional_and_default_together = require("./rules/no-optional-and-default-together.cjs");
+const require_no_promise_schema = require("./rules/no-promise-schema.cjs");
+const require_no_schema_with_is_nullable = require("./rules/no-schema-with-is-nullable.cjs");
 const require_no_schema_with_is_optional = require("./rules/no-schema-with-is-optional.cjs");
 const require_no_string_schema_with_uuid = require("./rules/no-string-schema-with-uuid.cjs");
 const require_no_throw_in_refine = require("./rules/no-throw-in-refine.cjs");
@@ -55,6 +57,8 @@ const eslintPluginZod = {
 		"no-number-schema-with-step": require_no_number_schema_with_step.noNumberSchemaWithStep,
 		"no-string-schema-with-uuid": require_no_string_schema_with_uuid.noStringSchemaWithUuid,
 		"no-optional-and-default-together": require_no_optional_and_default_together.noOptionalAndDefaultTogether,
+		"no-promise-schema": require_no_promise_schema.noPromiseSchema,
+		"no-schema-with-is-nullable": require_no_schema_with_is_nullable.noSchemaWithIsNullable,
 		"no-schema-with-is-optional": require_no_schema_with_is_optional.noSchemaWithIsOptional,
 		"no-throw-in-refine": require_no_throw_in_refine.noThrowInRefine,
 		"no-transform-in-record-key": require_no_transform_in_record_key.noTransformInRecordKey,
@@ -91,6 +95,8 @@ const recommendedConfig = {
 		"zod/no-number-schema-with-step": "error",
 		"zod/no-string-schema-with-uuid": "error",
 		"zod/no-optional-and-default-together": "error",
+		"zod/no-promise-schema": "error",
+		"zod/no-schema-with-is-nullable": "error",
 		"zod/no-schema-with-is-optional": "error",
 		"zod/no-throw-in-refine": "error",
 		"zod/prefer-enum-over-literal-union": "error",

package/dist/index.mjs

@@ -15,6 +15,8 @@ import { noNumberSchemaWithIsInt } from "./rules/no-number-schema-with-is-int.mj
 import { noNumberSchemaWithSafe } from "./rules/no-number-schema-with-safe.mjs";
 import { noNumberSchemaWithStep } from "./rules/no-number-schema-with-step.mjs";
 import { noOptionalAndDefaultTogether } from "./rules/no-optional-and-default-together.mjs";
+import { noPromiseSchema } from "./rules/no-promise-schema.mjs";
+import { noSchemaWithIsNullable } from "./rules/no-schema-with-is-nullable.mjs";
 import { noSchemaWithIsOptional } from "./rules/no-schema-with-is-optional.mjs";
 import { noStringSchemaWithUuid } from "./rules/no-string-schema-with-uuid.mjs";
 import { noThrowInRefine } from "./rules/no-throw-in-refine.mjs";
@@ -55,6 +57,8 @@ const eslintPluginZod = {
 		"no-number-schema-with-step": noNumberSchemaWithStep,
 		"no-string-schema-with-uuid": noStringSchemaWithUuid,
 		"no-optional-and-default-together": noOptionalAndDefaultTogether,
+		"no-promise-schema": noPromiseSchema,
+		"no-schema-with-is-nullable": noSchemaWithIsNullable,
 		"no-schema-with-is-optional": noSchemaWithIsOptional,
 		"no-throw-in-refine": noThrowInRefine,
 		"no-transform-in-record-key": noTransformInRecordKey,
@@ -91,6 +95,8 @@ const recommendedConfig = {
 		"zod/no-number-schema-with-step": "error",
 		"zod/no-string-schema-with-uuid": "error",
 		"zod/no-optional-and-default-together": "error",
+		"zod/no-promise-schema": "error",
+		"zod/no-schema-with-is-nullable": "error",
 		"zod/no-schema-with-is-optional": "error",
 		"zod/no-throw-in-refine": "error",
 		"zod/prefer-enum-over-literal-union": "error",

package/dist/rules/no-promise-schema.cjs

@@ -0,0 +1,30 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+let _eslint_zod_utils = require("@eslint-zod/utils");
+//#region src/rules/no-promise-schema.ts
+const { trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)(_eslint_zod_utils.zodImportScope);
+const noPromiseSchema = require_create_plugin_rule.createZodPluginRule({
+	name: "no-promise-schema",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow deprecated `z.promise()` schemas." },
+		messages: { noPromiseSchema: "`z.promise()` is deprecated in Zod 4. Await the value before parsing it instead." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				if (detectZodSchemaRootNode(node)?.schemaType !== "promise") return;
+				context.report({
+					node,
+					messageId: "noPromiseSchema"
+				});
+			}
+		};
+	}
+});
+//#endregion
+exports.noPromiseSchema = noPromiseSchema;

package/dist/rules/no-promise-schema.mjs

@@ -0,0 +1,29 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack, zodImportScope } from "@eslint-zod/utils";
+//#region src/rules/no-promise-schema.ts
+const { trackZodSchemaImports } = createZodSchemaImportTrack(zodImportScope);
+const noPromiseSchema = createZodPluginRule({
+	name: "no-promise-schema",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow deprecated `z.promise()` schemas." },
+		messages: { noPromiseSchema: "`z.promise()` is deprecated in Zod 4. Await the value before parsing it instead." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				if (detectZodSchemaRootNode(node)?.schemaType !== "promise") return;
+				context.report({
+					node,
+					messageId: "noPromiseSchema"
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { noPromiseSchema };

package/dist/rules/no-schema-with-is-nullable.cjs

@@ -0,0 +1,35 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+let _eslint_zod_utils = require("@eslint-zod/utils");
+//#region src/rules/no-schema-with-is-nullable.ts
+const { trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)(_eslint_zod_utils.zodImportScope);
+const noSchemaWithIsNullable = require_create_plugin_rule.createZodPluginRule({
+	name: "no-schema-with-is-nullable",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow deprecated `.isNullable()` on a Zod schema; use `safeParse(null).success` instead." },
+		messages: { useSafeParse: "`.isNullable()` is deprecated. Try `schema.safeParse(null).success` instead." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (!zodSchemaMeta) return;
+				const { methods } = zodSchemaMeta;
+				const isNullableIndex = methods.findIndex((it) => it === "isNullable");
+				if (isNullableIndex === -1) return;
+				if (methods.slice(0, isNullableIndex).some((method) => _eslint_zod_utils.ZOD_NON_SCHEMA_PRODUCING_METHODS.includes(method))) return;
+				context.report({
+					node,
+					messageId: "useSafeParse"
+				});
+			}
+		};
+	}
+});
+//#endregion
+exports.noSchemaWithIsNullable = noSchemaWithIsNullable;

package/dist/rules/no-schema-with-is-nullable.mjs

@@ -0,0 +1,34 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { ZOD_NON_SCHEMA_PRODUCING_METHODS, createZodSchemaImportTrack, zodImportScope } from "@eslint-zod/utils";
+//#region src/rules/no-schema-with-is-nullable.ts
+const { trackZodSchemaImports } = createZodSchemaImportTrack(zodImportScope);
+const noSchemaWithIsNullable = createZodPluginRule({
+	name: "no-schema-with-is-nullable",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow deprecated `.isNullable()` on a Zod schema; use `safeParse(null).success` instead." },
+		messages: { useSafeParse: "`.isNullable()` is deprecated. Try `schema.safeParse(null).success` instead." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (!zodSchemaMeta) return;
+				const { methods } = zodSchemaMeta;
+				const isNullableIndex = methods.findIndex((it) => it === "isNullable");
+				if (isNullableIndex === -1) return;
+				if (methods.slice(0, isNullableIndex).some((method) => ZOD_NON_SCHEMA_PRODUCING_METHODS.includes(method))) return;
+				context.report({
+					node,
+					messageId: "useSafeParse"
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { noSchemaWithIsNullable };

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

@@ -1,9 +1,7 @@
 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/prefer-enum-over-literal-union.ts
-const { trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)(_eslint_zod_utils.zodImportScope);
 const preferEnumOverLiteralUnion = require_create_plugin_rule.createZodPluginRule({
 	name: "prefer-enum-over-literal-union",
 	meta: {
@@ -14,42 +12,7 @@ const preferEnumOverLiteralUnion = require_create_plugin_rule.createZodPluginRul
 		schema: []
 	},
 	defaultOptions: [],
-	create(context) {
-		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
-		return {
-			ImportDeclaration: importDeclarationListener,
-			CallExpression(node) {
-				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);
-				if (unionArgument?.type !== _typescript_eslint_utils.AST_NODE_TYPES.ArrayExpression) return;
-				/**
-				* Collect zod literals name that later can be used to implement the fix,
-				* if the item isn't a literal schema return null
-				*/
-				const zodLiteralStrings = unionArgument.elements.map((s) => {
-					if (!s) return null;
-					const maybeLiteralSchema = detectZodSchemaRootNode(s);
-					if (maybeLiteralSchema?.schemaType !== "literal") return null;
-					const [literalArgument] = maybeLiteralSchema.node.arguments;
-					if (literalArgument.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && typeof literalArgument.value === "string") return literalArgument.raw;
-					return null;
-				});
-				if (zodLiteralStrings.some((it) => it === null)) 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(", ")}]`)];
-					}
-				});
-			}
-		};
-	}
+	create: (0, _eslint_zod_utils.buildPreferEnumOverLiteralUnionCreate)(_eslint_zod_utils.zodImportScope)
 });
 //#endregion
 exports.preferEnumOverLiteralUnion = preferEnumOverLiteralUnion;

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

@@ -1,8 +1,6 @@
 import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
-import { createZodSchemaImportTrack, zodImportScope } from "@eslint-zod/utils";
-import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { buildPreferEnumOverLiteralUnionCreate, zodImportScope } from "@eslint-zod/utils";
 //#region src/rules/prefer-enum-over-literal-union.ts
-const { trackZodSchemaImports } = createZodSchemaImportTrack(zodImportScope);
 const preferEnumOverLiteralUnion = createZodPluginRule({
 	name: "prefer-enum-over-literal-union",
 	meta: {
@@ -13,42 +11,7 @@ const preferEnumOverLiteralUnion = createZodPluginRule({
 		schema: []
 	},
 	defaultOptions: [],
-	create(context) {
-		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
-		return {
-			ImportDeclaration: importDeclarationListener,
-			CallExpression(node) {
-				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);
-				if (unionArgument?.type !== AST_NODE_TYPES.ArrayExpression) return;
-				/**
-				* Collect zod literals name that later can be used to implement the fix,
-				* if the item isn't a literal schema return null
-				*/
-				const zodLiteralStrings = unionArgument.elements.map((s) => {
-					if (!s) return null;
-					const maybeLiteralSchema = detectZodSchemaRootNode(s);
-					if (maybeLiteralSchema?.schemaType !== "literal") return null;
-					const [literalArgument] = maybeLiteralSchema.node.arguments;
-					if (literalArgument.type === AST_NODE_TYPES.Literal && typeof literalArgument.value === "string") return literalArgument.raw;
-					return null;
-				});
-				if (zodLiteralStrings.some((it) => it === null)) 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(", ")}]`)];
-					}
-				});
-			}
-		};
-	}
+	create: buildPreferEnumOverLiteralUnionCreate(zodImportScope)
 });
 //#endregion
 export { preferEnumOverLiteralUnion };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-zod",
-  "version": "4.3.0",
+  "version": "4.5.0",
   "description": "ESLint plugin that adds custom linting rules to enforce best practices when using Zod",
   "keywords": [
     "eslint",
@@ -40,17 +40,17 @@
   "dependencies": {
     "@typescript-eslint/utils": "^8.57.0",
     "esquery": "^1.6.0",
-    "@eslint-zod/utils": "1.2.0"
+    "@eslint-zod/utils": "1.3.0"
   },
   "devDependencies": {
     "@marcalexiei/prettier-config": "2.0.0",
     "@types/esquery": "1.5.4",
-    "@typescript-eslint/rule-tester": "8.59.2",
+    "@typescript-eslint/rule-tester": "8.59.3",
     "dedent": "1.7.2",
     "eslint-doc-generator": "3.3.2",
     "prettier": "3.8.3",
-    "tsdown": "0.21.10",
-    "vitest": "4.1.5"
+    "tsdown": "0.22.0",
+    "vitest": "4.1.6"
   },
   "peerDependencies": {
     "eslint": "^9 || ^10",