eslint-plugin-zod 4.7.1 → 4.8.0

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-coerce-boolean](docs/rules/no-coerce-boolean.md)                                             | Disallow `z.coerce.boolean()` because it treats any non-empty string as `true`.                                                | ✅  |     | 💡  |     |
+| [no-conflicting-checks](docs/rules/no-conflicting-checks.md)                                     | Disallow check combinations that can never match, are redundant, or do not apply to the schema type                            |     |     |     |     |
 | [no-duplicate-schema-methods](docs/rules/no-duplicate-schema-methods.md)                         | Disallow calling the same schema method more than once in a single chain                                                       | ✅  |     |     |     |
 | [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()`.                                                                   | ✅  | 🔧  |     |     |
@@ -59,6 +60,7 @@ Find out more about [Oxlint's `jsPLugins`](https://oxc.rs/docs/guide/usage/linte
 | [no-throw-in-refine](docs/rules/no-throw-in-refine.md)                                           | Disallow throwing errors directly inside Zod refine callbacks                                                                  | ✅  |     |     |     |
 | [no-transform-in-record-key](docs/rules/no-transform-in-record-key.md)                           | Disallow transforms in z.record() key schemas, which can cause silent key mutations and data loss through key collisions       |     |     |     |     |
 | [no-unknown-schema](docs/rules/no-unknown-schema.md)                                             | Disallow usage of `z.unknown()` in Zod schemas                                                                                 |     |     |     |     |
+| [no-unnecessary-readonly](docs/rules/no-unnecessary-readonly.md)                                 | Disallow `.readonly()` on schemas whose output is already immutable                                                            |     | 🔧  |     |     |
 | [prefer-enum-over-literal-union](docs/rules/prefer-enum-over-literal-union.md)                   | Prefer `z.enum()` over `z.union()` when all members are string literals.                                                       | ✅  | 🔧  |     |     |
 | [prefer-loose-object](docs/rules/prefer-loose-object.md)                                         | Prefer `z.looseObject()` over `z.object().passthrough()` and `z.object().loose()`                                              | ✅  | 🔧  |     |     |
 | [prefer-meta](docs/rules/prefer-meta.md)                                                         | Enforce usage of `.meta()` over `.describe()`                                                                                  | ✅  | 🔧  |     |     |
@@ -67,6 +69,7 @@ Find out more about [Oxlint's `jsPLugins`](https://oxc.rs/docs/guide/usage/linte
 | [prefer-string-schema-with-trim](docs/rules/prefer-string-schema-with-trim.md)                   | Enforce `z.string().trim()` to prevent accidental leading/trailing whitespace                                                  | ✅  | 🔧  |     |     |
 | [prefer-top-level-string-formats](docs/rules/prefer-top-level-string-formats.md)                 | Prefer top-level string format schemas over deprecated `z.string().<format>()` methods                                         | ✅  | 🔧  |     |     |
 | [prefer-trim-before-string-length-checks](docs/rules/prefer-trim-before-string-length-checks.md) | Enforce `.trim()` is called before string length checks to ensure accurate validation                                          | ✅  | 🔧  |     |     |
+| [prefer-tuple-over-array-length](docs/rules/prefer-tuple-over-array-length.md)                   | Prefer `z.tuple()` over a length-constrained `z.array()` so the length is preserved in the inferred type.                      |     | 🔧  |     |     |
 | [require-brand-type-parameter](docs/rules/require-brand-type-parameter.md)                       | Require type parameter on `.brand()` functions                                                                                 | ✅  |     | 💡  |     |
 | [require-error-message](docs/rules/require-error-message.md)                                     | Enforce that custom refinements include an error message                                                                       | ✅  | 🔧  |     |     |
 | [schema-error-property-style](docs/rules/schema-error-property-style.md)                         | Enforce consistent style for error messages in Zod schema validation (using ESQuery patterns)                                  |     |     |     |     |

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_coerce_boolean = require("./rules/no-coerce-boolean.cjs");
+const require_no_conflicting_checks = require("./rules/no-conflicting-checks.cjs");
 const require_no_duplicate_schema_methods = require("./rules/no-duplicate-schema-methods.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");
@@ -24,6 +25,7 @@ const require_no_string_schema_with_uuid = require("./rules/no-string-schema-wit
 const require_no_throw_in_refine = require("./rules/no-throw-in-refine.cjs");
 const require_no_transform_in_record_key = require("./rules/no-transform-in-record-key.cjs");
 const require_no_unknown_schema = require("./rules/no-unknown-schema.cjs");
+const require_no_unnecessary_readonly = require("./rules/no-unnecessary-readonly.cjs");
 const require_prefer_enum_over_literal_union = require("./rules/prefer-enum-over-literal-union.cjs");
 const require_prefer_loose_object = require("./rules/prefer-loose-object.cjs");
 const require_prefer_meta_last = require("./rules/prefer-meta-last.cjs");
@@ -32,6 +34,7 @@ const require_prefer_strict_object = require("./rules/prefer-strict-object.cjs")
 const require_prefer_string_schema_with_trim = require("./rules/prefer-string-schema-with-trim.cjs");
 const require_prefer_top_level_string_formats = require("./rules/prefer-top-level-string-formats.cjs");
 const require_prefer_trim_before_string_length_checks = require("./rules/prefer-trim-before-string-length-checks.cjs");
+const require_prefer_tuple_over_array_length = require("./rules/prefer-tuple-over-array-length.cjs");
 const require_require_brand_type_parameter = require("./rules/require-brand-type-parameter.cjs");
 const require_require_error_message = require("./rules/require-error-message.cjs");
 const require_schema_error_property_style = require("./rules/schema-error-property-style.cjs");
@@ -50,6 +53,7 @@ const eslintPluginZod = {
 		"consistent-schema-output-type-style": require_consistent_schema_output_type_style.consistentSchemaOutputTypeStyle,
 		"no-any-schema": require_no_any_schema.noAnySchema,
 		"no-coerce-boolean": require_no_coerce_boolean.noCoerceBoolean,
+		"no-conflicting-checks": require_no_conflicting_checks.noConflictingChecks,
 		"no-duplicate-schema-methods": require_no_duplicate_schema_methods.noDuplicateSchemaMethods,
 		"no-empty-custom-schema": require_no_empty_custom_schema.noEmptyCustomSchema,
 		"no-native-enum": require_no_native_enum.noNativeEnum,
@@ -67,6 +71,7 @@ const eslintPluginZod = {
 		"no-throw-in-refine": require_no_throw_in_refine.noThrowInRefine,
 		"no-transform-in-record-key": require_no_transform_in_record_key.noTransformInRecordKey,
 		"no-unknown-schema": require_no_unknown_schema.noUnknownSchema,
+		"no-unnecessary-readonly": require_no_unnecessary_readonly.noUnnecessaryReadonly,
 		"prefer-enum-over-literal-union": require_prefer_enum_over_literal_union.preferEnumOverLiteralUnion,
 		"prefer-loose-object": require_prefer_loose_object.preferLooseObject,
 		"prefer-meta": require_prefer_meta.preferMeta,
@@ -75,6 +80,7 @@ const eslintPluginZod = {
 		"prefer-top-level-string-formats": require_prefer_top_level_string_formats.preferTopLevelStringFormats,
 		"prefer-string-schema-with-trim": require_prefer_string_schema_with_trim.preferStringSchemaWithTrim,
 		"prefer-trim-before-string-length-checks": require_prefer_trim_before_string_length_checks.preferTrimBeforeStringLengthChecks,
+		"prefer-tuple-over-array-length": require_prefer_tuple_over_array_length.preferTupleOverArrayLength,
 		"require-brand-type-parameter": require_require_brand_type_parameter.requireBrandTypeParameter,
 		"require-error-message": require_require_error_message.requireErrorMessage,
 		"schema-error-property-style": require_schema_error_property_style.schemaErrorPropertyStyle

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 { noCoerceBoolean } from "./rules/no-coerce-boolean.mjs";
+import { noConflictingChecks } from "./rules/no-conflicting-checks.mjs";
 import { noDuplicateSchemaMethods } from "./rules/no-duplicate-schema-methods.mjs";
 import { noEmptyCustomSchema } from "./rules/no-empty-custom-schema.mjs";
 import { noNativeEnum } from "./rules/no-native-enum.mjs";
@@ -24,6 +25,7 @@ import { noStringSchemaWithUuid } from "./rules/no-string-schema-with-uuid.mjs";
 import { noThrowInRefine } from "./rules/no-throw-in-refine.mjs";
 import { noTransformInRecordKey } from "./rules/no-transform-in-record-key.mjs";
 import { noUnknownSchema } from "./rules/no-unknown-schema.mjs";
+import { noUnnecessaryReadonly } from "./rules/no-unnecessary-readonly.mjs";
 import { preferEnumOverLiteralUnion } from "./rules/prefer-enum-over-literal-union.mjs";
 import { preferLooseObject } from "./rules/prefer-loose-object.mjs";
 import { preferMetaLast } from "./rules/prefer-meta-last.mjs";
@@ -32,6 +34,7 @@ import { preferStrictObject } from "./rules/prefer-strict-object.mjs";
 import { preferStringSchemaWithTrim } from "./rules/prefer-string-schema-with-trim.mjs";
 import { preferTopLevelStringFormats } from "./rules/prefer-top-level-string-formats.mjs";
 import { preferTrimBeforeStringLengthChecks } from "./rules/prefer-trim-before-string-length-checks.mjs";
+import { preferTupleOverArrayLength } from "./rules/prefer-tuple-over-array-length.mjs";
 import { requireBrandTypeParameter } from "./rules/require-brand-type-parameter.mjs";
 import { requireErrorMessage } from "./rules/require-error-message.mjs";
 import { schemaErrorPropertyStyle } from "./rules/schema-error-property-style.mjs";
@@ -50,6 +53,7 @@ const eslintPluginZod = {
 		"consistent-schema-output-type-style": consistentSchemaOutputTypeStyle,
 		"no-any-schema": noAnySchema,
 		"no-coerce-boolean": noCoerceBoolean,
+		"no-conflicting-checks": noConflictingChecks,
 		"no-duplicate-schema-methods": noDuplicateSchemaMethods,
 		"no-empty-custom-schema": noEmptyCustomSchema,
 		"no-native-enum": noNativeEnum,
@@ -67,6 +71,7 @@ const eslintPluginZod = {
 		"no-throw-in-refine": noThrowInRefine,
 		"no-transform-in-record-key": noTransformInRecordKey,
 		"no-unknown-schema": noUnknownSchema,
+		"no-unnecessary-readonly": noUnnecessaryReadonly,
 		"prefer-enum-over-literal-union": preferEnumOverLiteralUnion,
 		"prefer-loose-object": preferLooseObject,
 		"prefer-meta": preferMeta,
@@ -75,6 +80,7 @@ const eslintPluginZod = {
 		"prefer-top-level-string-formats": preferTopLevelStringFormats,
 		"prefer-string-schema-with-trim": preferStringSchemaWithTrim,
 		"prefer-trim-before-string-length-checks": preferTrimBeforeStringLengthChecks,
+		"prefer-tuple-over-array-length": preferTupleOverArrayLength,
 		"require-brand-type-parameter": requireBrandTypeParameter,
 		"require-error-message": requireErrorMessage,
 		"schema-error-property-style": schemaErrorPropertyStyle

package/dist/rules/no-conflicting-checks.cjs

@@ -0,0 +1,44 @@
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+let _eslint_zod_utils = require("@eslint-zod/utils");
+let _eslint_zod_utils_rule_builders_no_conflicting_checks = require("@eslint-zod/utils/rule-builders/no-conflicting-checks");
+//#region src/rules/no-conflicting-checks.ts
+const noConflictingChecks = require_create_plugin_rule.createZodPluginRule({
+	name: "no-conflicting-checks",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow check combinations that can never match, are redundant, or do not apply to the schema type" },
+		messages: {
+			impossibleCase: "This schema can never match: `{{first}}` conflicts with `{{second}}`.",
+			redundantCheck: "`{{redundant}}` is redundant: `{{by}}` already implies it.",
+			confusingCombination: "Combining `{{first}}` and `{{second}}` is almost certainly a mistake.",
+			pointlessCheck: "`{{check}}` is pointless here: {{reason}}.",
+			inapplicableCheck: "`{{check}}` does not apply to a `{{baseType}}` schema: it will silently no-op or reject every value."
+		},
+		schema: [{
+			type: "object",
+			properties: {
+				checkImpossibleCases: {
+					description: "Report provably unsatisfiable combinations — the schema can never match",
+					type: "boolean"
+				},
+				checkConfusingCases: {
+					description: "Report technically valid but almost certainly mistaken combinations",
+					type: "boolean"
+				},
+				checkInapplicableChecks: {
+					description: "Report checks that don't apply to the schema's base type",
+					type: "boolean"
+				}
+			},
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{
+		checkImpossibleCases: true,
+		checkConfusingCases: true,
+		checkInapplicableChecks: true
+	}],
+	create: (0, _eslint_zod_utils_rule_builders_no_conflicting_checks.buildNoConflictingChecksCreate)(_eslint_zod_utils.zodImportScope)
+});
+//#endregion
+exports.noConflictingChecks = noConflictingChecks;

package/dist/rules/no-conflicting-checks.mjs

@@ -0,0 +1,44 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { zodImportScope } from "@eslint-zod/utils";
+import { buildNoConflictingChecksCreate } from "@eslint-zod/utils/rule-builders/no-conflicting-checks";
+//#region src/rules/no-conflicting-checks.ts
+const noConflictingChecks = createZodPluginRule({
+	name: "no-conflicting-checks",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow check combinations that can never match, are redundant, or do not apply to the schema type" },
+		messages: {
+			impossibleCase: "This schema can never match: `{{first}}` conflicts with `{{second}}`.",
+			redundantCheck: "`{{redundant}}` is redundant: `{{by}}` already implies it.",
+			confusingCombination: "Combining `{{first}}` and `{{second}}` is almost certainly a mistake.",
+			pointlessCheck: "`{{check}}` is pointless here: {{reason}}.",
+			inapplicableCheck: "`{{check}}` does not apply to a `{{baseType}}` schema: it will silently no-op or reject every value."
+		},
+		schema: [{
+			type: "object",
+			properties: {
+				checkImpossibleCases: {
+					description: "Report provably unsatisfiable combinations — the schema can never match",
+					type: "boolean"
+				},
+				checkConfusingCases: {
+					description: "Report technically valid but almost certainly mistaken combinations",
+					type: "boolean"
+				},
+				checkInapplicableChecks: {
+					description: "Report checks that don't apply to the schema's base type",
+					type: "boolean"
+				}
+			},
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{
+		checkImpossibleCases: true,
+		checkConfusingCases: true,
+		checkInapplicableChecks: true
+	}],
+	create: buildNoConflictingChecksCreate(zodImportScope)
+});
+//#endregion
+export { noConflictingChecks };

package/dist/rules/no-unnecessary-readonly.cjs

@@ -0,0 +1,18 @@
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+let _eslint_zod_utils = require("@eslint-zod/utils");
+let _eslint_zod_utils_rule_builders_no_unnecessary_readonly = require("@eslint-zod/utils/rule-builders/no-unnecessary-readonly");
+//#region src/rules/no-unnecessary-readonly.ts
+const noUnnecessaryReadonly = require_create_plugin_rule.createZodPluginRule({
+	name: "no-unnecessary-readonly",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: { description: "Disallow `.readonly()` on schemas whose output is already immutable" },
+		messages: { unnecessaryReadonly: "`readonly` has no effect on an already-immutable schema; remove it." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: (0, _eslint_zod_utils_rule_builders_no_unnecessary_readonly.buildNoUnnecessaryReadonlyCreate)(_eslint_zod_utils.zodImportScope)
+});
+//#endregion
+exports.noUnnecessaryReadonly = noUnnecessaryReadonly;

package/dist/rules/no-unnecessary-readonly.mjs

@@ -0,0 +1,18 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { zodImportScope } from "@eslint-zod/utils";
+import { buildNoUnnecessaryReadonlyCreate } from "@eslint-zod/utils/rule-builders/no-unnecessary-readonly";
+//#region src/rules/no-unnecessary-readonly.ts
+const noUnnecessaryReadonly = createZodPluginRule({
+	name: "no-unnecessary-readonly",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: { description: "Disallow `.readonly()` on schemas whose output is already immutable" },
+		messages: { unnecessaryReadonly: "`readonly` has no effect on an already-immutable schema; remove it." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: buildNoUnnecessaryReadonlyCreate(zodImportScope)
+});
+//#endregion
+export { noUnnecessaryReadonly };

package/dist/rules/prefer-tuple-over-array-length.cjs

@@ -0,0 +1,18 @@
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+let _eslint_zod_utils = require("@eslint-zod/utils");
+let _eslint_zod_utils_rule_builders_prefer_tuple_over_array_length = require("@eslint-zod/utils/rule-builders/prefer-tuple-over-array-length");
+//#region src/rules/prefer-tuple-over-array-length.ts
+const preferTupleOverArrayLength = require_create_plugin_rule.createZodPluginRule({
+	name: "prefer-tuple-over-array-length",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: { description: "Prefer `z.tuple()` over a length-constrained `z.array()` so the length is preserved in the inferred type." },
+		messages: { preferTuple: "Prefer `z.tuple()` over a length-constrained `z.array()` so the length is preserved in the inferred type." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: (0, _eslint_zod_utils_rule_builders_prefer_tuple_over_array_length.buildPreferTupleOverArrayLengthCreate)(_eslint_zod_utils.zodImportScope)
+});
+//#endregion
+exports.preferTupleOverArrayLength = preferTupleOverArrayLength;

package/dist/rules/prefer-tuple-over-array-length.mjs

@@ -0,0 +1,18 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { zodImportScope } from "@eslint-zod/utils";
+import { buildPreferTupleOverArrayLengthCreate } from "@eslint-zod/utils/rule-builders/prefer-tuple-over-array-length";
+//#region src/rules/prefer-tuple-over-array-length.ts
+const preferTupleOverArrayLength = createZodPluginRule({
+	name: "prefer-tuple-over-array-length",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: { description: "Prefer `z.tuple()` over a length-constrained `z.array()` so the length is preserved in the inferred type." },
+		messages: { preferTuple: "Prefer `z.tuple()` over a length-constrained `z.array()` so the length is preserved in the inferred type." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: buildPreferTupleOverArrayLengthCreate(zodImportScope)
+});
+//#endregion
+export { preferTupleOverArrayLength };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-zod",
-  "version": "4.7.1",
+  "version": "4.8.0",
   "description": "ESLint plugin that adds custom linting rules to enforce best practices when using Zod",
   "keywords": [
     "eslint",
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "@typescript-eslint/utils": "^8.62.0",
-    "@eslint-zod/utils": "2.3.0"
+    "@eslint-zod/utils": "2.4.0"
   },
   "devDependencies": {
     "@marcalexiei/prettier-config": "2.0.0",