eslint-plugin-zod-mini 1.9.0 → 1.10.0

package/README.md

@@ -42,7 +42,9 @@ Find out more about [Oxlint's `jsPLugins`](https://oxc.rs/docs/guide/usage/linte
 | [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-dynamic-schema-value](docs/rules/no-dynamic-schema-value.md)                         | Disallow non-static values passed as arguments in a Zod Mini schema expression                                           |     |     |     |
 | [no-empty-custom-schema](docs/rules/no-empty-custom-schema.md)                           | Disallow usage of `z.custom()` without arguments                                                                         | ✅  |     |     |
+| [no-function-scoped-schema](docs/rules/no-function-scoped-schema.md)                     | Disallow constructing a Zod Mini schema inside a function body                                                           |     |     |     |
 | [no-native-enum](docs/rules/no-native-enum.md)                                           | Disallow deprecated `z.nativeEnum()` in favor of `z.enum()`.                                                             | ✅  | 🔧  |     |
 | [no-promise-schema](docs/rules/no-promise-schema.md)                                     | Disallow deprecated `z.promise()` schemas.                                                                               | ✅  |     |     |
 | [no-throw-in-refine](docs/rules/no-throw-in-refine.md)                                   | Disallow throwing errors directly inside Zod Mini refine callbacks                                                       | ✅  |     |     |
@@ -55,6 +57,7 @@ Find out more about [Oxlint's `jsPLugins`](https://oxc.rs/docs/guide/usage/linte
 | [prefer-nullish](docs/rules/prefer-nullish.md)                                           | Enforce `z.nullish()` instead of combining `z.optional()` and `z.nullable()`                                             | ✅  | 🔧  |     |
 | [prefer-string-length-over-min-max](docs/rules/prefer-string-length-over-min-max.md)     | Prefer `z.length(n)` over `z.minLength(n)` and `z.maxLength(n)` with the same value on a string schema                   |     | 🔧  |     |
 | [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.                |     | 🔧  |     |
+| [prefer-validate](docs/rules/prefer-validate.md)                                         | Prefer boolean validation when only the success of parsing is used                                                       |     |     | 💡  |
 | [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 Mini schema validation (using ESQuery patterns)                       |     |     |     |

package/dist/index.cjs

@@ -8,7 +8,9 @@ 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_dynamic_schema_value = require("./rules/no-dynamic-schema-value.cjs");
 const require_no_empty_custom_schema = require("./rules/no-empty-custom-schema.cjs");
+const require_no_function_scoped_schema = require("./rules/no-function-scoped-schema.cjs");
 const require_no_native_enum = require("./rules/no-native-enum.cjs");
 const require_no_promise_schema = require("./rules/no-promise-schema.cjs");
 const require_no_throw_in_refine = require("./rules/no-throw-in-refine.cjs");
@@ -21,6 +23,7 @@ const require_prefer_meta = require("./rules/prefer-meta.cjs");
 const require_prefer_nullish = require("./rules/prefer-nullish.cjs");
 const require_prefer_string_length_over_min_max = require("./rules/prefer-string-length-over-min-max.cjs");
 const require_prefer_tuple_over_array_length = require("./rules/prefer-tuple-over-array-length.cjs");
+const require_prefer_validate = require("./rules/prefer-validate.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");
@@ -40,7 +43,9 @@ const eslintPluginZodMini = {
 		"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-dynamic-schema-value": require_no_dynamic_schema_value.noDynamicSchemaValue,
 		"no-empty-custom-schema": require_no_empty_custom_schema.noEmptyCustomSchema,
+		"no-function-scoped-schema": require_no_function_scoped_schema.noFunctionScopedSchema,
 		"no-native-enum": require_no_native_enum.noNativeEnum,
 		"no-promise-schema": require_no_promise_schema.noPromiseSchema,
 		"no-throw-in-refine": require_no_throw_in_refine.noThrowInRefine,
@@ -53,6 +58,7 @@ const eslintPluginZodMini = {
 		"prefer-nullish": require_prefer_nullish.preferNullish,
 		"prefer-string-length-over-min-max": require_prefer_string_length_over_min_max.preferStringLengthOverMinMax,
 		"prefer-tuple-over-array-length": require_prefer_tuple_over_array_length.preferTupleOverArrayLength,
+		"prefer-validate": require_prefer_validate.preferValidate,
 		"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

@@ -8,7 +8,9 @@ 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 { noDynamicSchemaValue } from "./rules/no-dynamic-schema-value.mjs";
 import { noEmptyCustomSchema } from "./rules/no-empty-custom-schema.mjs";
+import { noFunctionScopedSchema } from "./rules/no-function-scoped-schema.mjs";
 import { noNativeEnum } from "./rules/no-native-enum.mjs";
 import { noPromiseSchema } from "./rules/no-promise-schema.mjs";
 import { noThrowInRefine } from "./rules/no-throw-in-refine.mjs";
@@ -21,6 +23,7 @@ import { preferMeta } from "./rules/prefer-meta.mjs";
 import { preferNullish } from "./rules/prefer-nullish.mjs";
 import { preferStringLengthOverMinMax } from "./rules/prefer-string-length-over-min-max.mjs";
 import { preferTupleOverArrayLength } from "./rules/prefer-tuple-over-array-length.mjs";
+import { preferValidate } from "./rules/prefer-validate.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";
@@ -40,7 +43,9 @@ const eslintPluginZodMini = {
 		"no-coerce-boolean": noCoerceBoolean,
 		"no-conflicting-checks": noConflictingChecks,
 		"no-duplicate-schema-methods": noDuplicateSchemaMethods,
+		"no-dynamic-schema-value": noDynamicSchemaValue,
 		"no-empty-custom-schema": noEmptyCustomSchema,
+		"no-function-scoped-schema": noFunctionScopedSchema,
 		"no-native-enum": noNativeEnum,
 		"no-promise-schema": noPromiseSchema,
 		"no-throw-in-refine": noThrowInRefine,
@@ -53,6 +58,7 @@ const eslintPluginZodMini = {
 		"prefer-nullish": preferNullish,
 		"prefer-string-length-over-min-max": preferStringLengthOverMinMax,
 		"prefer-tuple-over-array-length": preferTupleOverArrayLength,
+		"prefer-validate": preferValidate,
 		"require-brand-type-parameter": requireBrandTypeParameter,
 		"require-error-message": requireErrorMessage,
 		"schema-error-property-style": schemaErrorPropertyStyle

package/dist/rules/no-dynamic-schema-value.cjs

@@ -0,0 +1,17 @@
+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_dynamic_schema_value = require("@eslint-zod/utils/rule-builders/no-dynamic-schema-value");
+//#region src/rules/no-dynamic-schema-value.ts
+const noDynamicSchemaValue = require_create_plugin_rule.createZodMiniPluginRule({
+	name: "no-dynamic-schema-value",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow non-static values passed as arguments in a Zod Mini schema expression" },
+		messages: { dynamicValue: "This value must be a literal or an imported binding to be hoistable by tools like `zod-compiler`." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: (0, _eslint_zod_utils_rule_builders_no_dynamic_schema_value.buildNoDynamicSchemaValueCreate)(_eslint_zod_utils.zodMiniImportScope)
+});
+//#endregion
+exports.noDynamicSchemaValue = noDynamicSchemaValue;

package/dist/rules/no-dynamic-schema-value.mjs

@@ -0,0 +1,17 @@
+import { createZodMiniPluginRule } from "../utils/create-plugin-rule.mjs";
+import { zodMiniImportScope } from "@eslint-zod/utils";
+import { buildNoDynamicSchemaValueCreate } from "@eslint-zod/utils/rule-builders/no-dynamic-schema-value";
+//#region src/rules/no-dynamic-schema-value.ts
+const noDynamicSchemaValue = createZodMiniPluginRule({
+	name: "no-dynamic-schema-value",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow non-static values passed as arguments in a Zod Mini schema expression" },
+		messages: { dynamicValue: "This value must be a literal or an imported binding to be hoistable by tools like `zod-compiler`." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: buildNoDynamicSchemaValueCreate(zodMiniImportScope)
+});
+//#endregion
+export { noDynamicSchemaValue };

package/dist/rules/no-function-scoped-schema.cjs

@@ -0,0 +1,17 @@
+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_function_scoped_schema = require("@eslint-zod/utils/rule-builders/no-function-scoped-schema");
+//#region src/rules/no-function-scoped-schema.ts
+const noFunctionScopedSchema = require_create_plugin_rule.createZodMiniPluginRule({
+	name: "no-function-scoped-schema",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow constructing a Zod Mini schema inside a function body" },
+		messages: { functionScopedSchema: "This schema is constructed inside a function and rebuilt on every call. Declare it once at module scope instead." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: (0, _eslint_zod_utils_rule_builders_no_function_scoped_schema.buildNoFunctionScopedSchemaCreate)(_eslint_zod_utils.zodMiniImportScope)
+});
+//#endregion
+exports.noFunctionScopedSchema = noFunctionScopedSchema;

package/dist/rules/no-function-scoped-schema.mjs

@@ -0,0 +1,17 @@
+import { createZodMiniPluginRule } from "../utils/create-plugin-rule.mjs";
+import { zodMiniImportScope } from "@eslint-zod/utils";
+import { buildNoFunctionScopedSchemaCreate } from "@eslint-zod/utils/rule-builders/no-function-scoped-schema";
+//#region src/rules/no-function-scoped-schema.ts
+const noFunctionScopedSchema = createZodMiniPluginRule({
+	name: "no-function-scoped-schema",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow constructing a Zod Mini schema inside a function body" },
+		messages: { functionScopedSchema: "This schema is constructed inside a function and rebuilt on every call. Declare it once at module scope instead." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: buildNoFunctionScopedSchemaCreate(zodMiniImportScope)
+});
+//#endregion
+export { noFunctionScopedSchema };

package/dist/rules/no-transform-in-record-key.cjs

@@ -1,6 +1,5 @@
 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");
 let _eslint_zod_utils_rule_builders_no_transform_in_record_key = require("@eslint-zod/utils/rule-builders/no-transform-in-record-key");
 //#region src/rules/no-transform-in-record-key.ts
 const noTransformInRecordKey = require_create_plugin_rule.createZodMiniPluginRule({
@@ -12,18 +11,7 @@ const noTransformInRecordKey = require_create_plugin_rule.createZodMiniPluginRul
 		schema: []
 	},
 	defaultOptions: [],
-	create: (0, _eslint_zod_utils_rule_builders_no_transform_in_record_key.buildNoTransformInRecordKeyCreate)(_eslint_zod_utils.zodMiniImportScope, { findTransformNode(keySchema, { detectZodSchemaRootNode, collectZodChainMethods }) {
-		if (keySchema.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return null;
-		for (const method of collectZodChainMethods(keySchema)) {
-			if (method.name !== "check") continue;
-			for (const argument of method.node.arguments) {
-				if (argument.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) continue;
-				const zodCheck = detectZodSchemaRootNode(argument);
-				if (zodCheck && _eslint_zod_utils.ZOD_MUTATING_CHECK_NAMES.includes(zodCheck.schemaType)) return argument;
-			}
-		}
-		return null;
-	} })
+	create: (0, _eslint_zod_utils_rule_builders_no_transform_in_record_key.buildNoTransformInRecordKeyCreate)(_eslint_zod_utils.zodMiniImportScope, _eslint_zod_utils.ZOD_MUTATING_CHECK_NAMES)
 });
 //#endregion
 exports.noTransformInRecordKey = noTransformInRecordKey;

package/dist/rules/no-transform-in-record-key.mjs

@@ -1,6 +1,5 @@
 import { createZodMiniPluginRule } from "../utils/create-plugin-rule.mjs";
 import { ZOD_MUTATING_CHECK_NAMES, zodMiniImportScope } from "@eslint-zod/utils";
-import { AST_NODE_TYPES } from "@typescript-eslint/utils";
 import { buildNoTransformInRecordKeyCreate } from "@eslint-zod/utils/rule-builders/no-transform-in-record-key";
 //#region src/rules/no-transform-in-record-key.ts
 const noTransformInRecordKey = createZodMiniPluginRule({
@@ -12,18 +11,7 @@ const noTransformInRecordKey = createZodMiniPluginRule({
 		schema: []
 	},
 	defaultOptions: [],
-	create: buildNoTransformInRecordKeyCreate(zodMiniImportScope, { findTransformNode(keySchema, { detectZodSchemaRootNode, collectZodChainMethods }) {
-		if (keySchema.type !== AST_NODE_TYPES.CallExpression) return null;
-		for (const method of collectZodChainMethods(keySchema)) {
-			if (method.name !== "check") continue;
-			for (const argument of method.node.arguments) {
-				if (argument.type !== AST_NODE_TYPES.CallExpression) continue;
-				const zodCheck = detectZodSchemaRootNode(argument);
-				if (zodCheck && ZOD_MUTATING_CHECK_NAMES.includes(zodCheck.schemaType)) return argument;
-			}
-		}
-		return null;
-	} })
+	create: buildNoTransformInRecordKeyCreate(zodMiniImportScope, ZOD_MUTATING_CHECK_NAMES)
 });
 //#endregion
 export { noTransformInRecordKey };

package/dist/rules/prefer-meta.cjs

@@ -12,7 +12,7 @@ const preferMeta = require_create_plugin_rule.createZodMiniPluginRule({
 	},
 	defaultOptions: [],
 	create(context) {
-		const { createSchemaVisitor } = _eslint_zod_utils.zodMiniImportScope.createTracker();
+		const { createSchemaVisitor } = _eslint_zod_utils.zodMiniImportScope.createTracker({ kind: "value" });
 		return createSchemaVisitor({
 			schemaType: "describe",
 			onSchema(node, zodSchemaMeta) {

package/dist/rules/prefer-meta.mjs

@@ -12,7 +12,7 @@ const preferMeta = createZodMiniPluginRule({
 	},
 	defaultOptions: [],
 	create(context) {
-		const { createSchemaVisitor } = zodMiniImportScope.createTracker();
+		const { createSchemaVisitor } = zodMiniImportScope.createTracker({ kind: "value" });
 		return createSchemaVisitor({
 			schemaType: "describe",
 			onSchema(node, zodSchemaMeta) {

package/dist/rules/prefer-validate.cjs

@@ -0,0 +1,21 @@
+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_validate = require("@eslint-zod/utils/rule-builders/prefer-validate");
+//#region src/rules/prefer-validate.ts
+const preferValidate = require_create_plugin_rule.createZodMiniPluginRule({
+	name: "prefer-validate",
+	meta: {
+		type: "suggestion",
+		hasSuggestions: true,
+		docs: { description: "Prefer boolean validation when only the success of parsing is used" },
+		messages: {
+			preferValidate: "Prefer `{{method}}` when only parse success is used.",
+			useValidate: "Replace success-only parsing with `{{method}}`."
+		},
+		schema: []
+	},
+	defaultOptions: [],
+	create: (0, _eslint_zod_utils_rule_builders_prefer_validate.buildPreferValidateCreate)(_eslint_zod_utils.zodMiniImportScope, "standalone")
+});
+//#endregion
+exports.preferValidate = preferValidate;

package/dist/rules/prefer-validate.mjs

@@ -0,0 +1,21 @@
+import { createZodMiniPluginRule } from "../utils/create-plugin-rule.mjs";
+import { zodMiniImportScope } from "@eslint-zod/utils";
+import { buildPreferValidateCreate } from "@eslint-zod/utils/rule-builders/prefer-validate";
+//#region src/rules/prefer-validate.ts
+const preferValidate = createZodMiniPluginRule({
+	name: "prefer-validate",
+	meta: {
+		type: "suggestion",
+		hasSuggestions: true,
+		docs: { description: "Prefer boolean validation when only the success of parsing is used" },
+		messages: {
+			preferValidate: "Prefer `{{method}}` when only parse success is used.",
+			useValidate: "Replace success-only parsing with `{{method}}`."
+		},
+		schema: []
+	},
+	defaultOptions: [],
+	create: buildPreferValidateCreate(zodMiniImportScope, "standalone")
+});
+//#endregion
+export { preferValidate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-zod-mini",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "ESLint plugin that adds custom linting rules to enforce best practices when using Zod Mini",
   "keywords": [
     "eslint",
@@ -38,15 +38,16 @@
     "access": "public"
   },
   "dependencies": {
-    "@typescript-eslint/utils": "^8.67.0",
-    "@eslint-zod/utils": "3.3.0"
+    "@typescript-eslint/utils": "^8.70.0",
+    "@eslint-zod/utils": "5.0.0"
   },
   "devDependencies": {
-    "@typescript-eslint/rule-tester": "8.67.0",
+    "@arethetypeswrong/cli": "0.18.5",
+    "@typescript-eslint/rule-tester": "8.70.0",
     "dedent": "1.7.2",
-    "eslint-doc-generator": "3.7.0",
-    "tsdown": "0.22.14",
-    "vitest": "4.1.11",
+    "eslint-doc-generator": "3.7.1",
+    "tsdown": "0.23.0",
+    "vitest": "5.0.0",
     "@eslint-zod/tooling": "0.0.0"
   },
   "peerDependencies": {
@@ -70,6 +71,7 @@
   },
   "scripts": {
     "build": "tsdown",
+    "lint:publish": "attw --pack .",
     "build:docs": "pnpm run build && eslint-doc-generator",
     "lint:docs": "eslint-doc-generator --check",
     "test": "vitest"