eslint-plugin-zod 3.9.0 → 3.11.0

package/README.md

@@ -44,6 +44,7 @@ This plugin is primarily built for `zod`, so some rules are exclusive to `zod` a
 | [consistent-import-source](docs/rules/consistent-import-source.md)                       | Enforce consistent source from Zod imports                                                    |       |     | 💡  |     |
 | [consistent-object-schema-type](docs/rules/consistent-object-schema-type.md)             | Enforce consistent usage of Zod schema methods                                                |       |     | 💡  |     |
 | [consistent-schema-output-type-style](docs/rules/consistent-schema-output-type-style.md) | Enforce consistent use of z.infer or z.output for schema type inference                       |       | 🔧  |     |     |
+| [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-unknown-schema](docs/rules/no-unknown-schema.md)                                     | Disallow usage of `z.unknown()` in Zod schemas                                                |       |     |     |     |
@@ -51,7 +52,7 @@ This plugin is primarily built for `zod`, so some rules are exclusive to `zod` a
 | [prefer-namespace-import](docs/rules/prefer-namespace-import.md)                         | Enforce importing zod as a namespace import (`import * as z from 'zod'`)                      |       | 🔧  |     | ❌  |
 | [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                                      | ✅ ✔️ | 🔧  |     |     |
-| [require-schema-suffix](docs/rules/require-schema-suffix.md)                             | Require schema suffix when declaring a Zod schema                                             | ✅ ✔️ |     |     |     |
+| [require-schema-suffix](docs/rules/require-schema-suffix.md)                             | Require schema suffix when declaring a Zod schema                                             |       |     |     | ❌  |
 | [schema-error-property-style](docs/rules/schema-error-property-style.md)                 | Enforce consistent style for error messages in Zod schema validation (using ESQuery patterns) |       |     |     |     |
 
 ### `zod` exclusive rules

package/dist/index.cjs

@@ -4,6 +4,7 @@ const require_consistent_import_source = require("./rules/consistent-import-sour
 const require_consistent_import = require("./rules/consistent-import.cjs");
 const require_consistent_object_schema_type = require("./rules/consistent-object-schema-type.cjs");
 const require_consistent_schema_output_type_style = require("./rules/consistent-schema-output-type-style.cjs");
+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_number_schema_with_finite = require("./rules/no-number-schema-with-finite.cjs");
@@ -37,6 +38,7 @@ const eslintPluginZod = {
 		"consistent-import-source": require_consistent_import_source.consistentImportSource,
 		"consistent-import": require_consistent_import.consistentImport,
 		"consistent-object-schema-type": require_consistent_object_schema_type.consistentObjectSchemaType,
+		"consistent-schema-var-name": require_consistent_schema_var_name.consistentSchemaVarName,
 		"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,
@@ -72,6 +74,7 @@ const recommendedConfig = {
 	rules: {
 		"zod/array-style": "error",
 		"zod/consistent-import": "error",
+		"zod/consistent-schema-var-name": "error",
 		"zod/no-any-schema": "error",
 		"zod/no-empty-custom-schema": "error",
 		"zod/no-number-schema-with-finite": "error",
@@ -88,18 +91,17 @@ const recommendedConfig = {
 		"zod/prefer-meta-last": "error",
 		"zod/prefer-string-schema-with-trim": "error",
 		"zod/require-brand-type-parameter": "error",
-		"zod/require-error-message": "error",
-		"zod/require-schema-suffix": "error"
+		"zod/require-error-message": "error"
 	}
 };
 const recommendedConfigMini = {
 	...baseConfig,
 	rules: {
+		"zod/consistent-schema-var-name": "error",
 		"zod/no-any-schema": "error",
 		"zod/prefer-meta": "error",
 		"zod/require-brand-type-parameter": "error",
-		"zod/require-error-message": "error",
-		"zod/require-schema-suffix": "error"
+		"zod/require-error-message": "error"
 	}
 };
 var src_default = {

package/dist/index.mjs

@@ -4,6 +4,7 @@ import { consistentImportSource } from "./rules/consistent-import-source.mjs";
 import { consistentImport } from "./rules/consistent-import.mjs";
 import { consistentObjectSchemaType } from "./rules/consistent-object-schema-type.mjs";
 import { consistentSchemaOutputTypeStyle } from "./rules/consistent-schema-output-type-style.mjs";
+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 { noNumberSchemaWithFinite } from "./rules/no-number-schema-with-finite.mjs";
@@ -37,6 +38,7 @@ const eslintPluginZod = {
 		"consistent-import-source": consistentImportSource,
 		"consistent-import": consistentImport,
 		"consistent-object-schema-type": consistentObjectSchemaType,
+		"consistent-schema-var-name": consistentSchemaVarName,
 		"consistent-schema-output-type-style": consistentSchemaOutputTypeStyle,
 		"no-any-schema": noAnySchema,
 		"no-empty-custom-schema": noEmptyCustomSchema,
@@ -72,6 +74,7 @@ const recommendedConfig = {
 	rules: {
 		"zod/array-style": "error",
 		"zod/consistent-import": "error",
+		"zod/consistent-schema-var-name": "error",
 		"zod/no-any-schema": "error",
 		"zod/no-empty-custom-schema": "error",
 		"zod/no-number-schema-with-finite": "error",
@@ -88,18 +91,17 @@ const recommendedConfig = {
 		"zod/prefer-meta-last": "error",
 		"zod/prefer-string-schema-with-trim": "error",
 		"zod/require-brand-type-parameter": "error",
-		"zod/require-error-message": "error",
-		"zod/require-schema-suffix": "error"
+		"zod/require-error-message": "error"
 	}
 };
 const recommendedConfigMini = {
 	...baseConfig,
 	rules: {
+		"zod/consistent-schema-var-name": "error",
 		"zod/no-any-schema": "error",
 		"zod/prefer-meta": "error",
 		"zod/require-brand-type-parameter": "error",
-		"zod/require-error-message": "error",
-		"zod/require-schema-suffix": "error"
+		"zod/require-error-message": "error"
 	}
 };
 var src_default = {

package/dist/rules/consistent-schema-var-name.cjs

@@ -0,0 +1,76 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+const require_track_zod_schema_imports = require("../utils/track-zod-schema-imports.cjs");
+let _typescript_eslint_utils = require("@typescript-eslint/utils");
+//#region src/rules/consistent-schema-var-name.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = require_track_zod_schema_imports.createZodSchemaImportTrack("all");
+const consistentSchemaVarName = require_create_plugin_rule.createZodPluginRule({
+	name: "consistent-schema-var-name",
+	meta: {
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Enforce a consistent naming convention for Zod schema variables"
+		},
+		messages: { invalidName: "Rename this Zod schema to \"{{expected}}\"" },
+		schema: [{
+			type: "object",
+			properties: {
+				before: {
+					type: "string",
+					description: "The required prefix for Zod schema variables"
+				},
+				after: {
+					type: "string",
+					description: "The required suffix for Zod schema variables"
+				}
+			},
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{ after: "Schema" }],
+	create(context, [{ before = "", after = "" }]) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			VariableDeclarator(node) {
+				const initNode = node.init;
+				if (initNode?.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression || !detectZodSchemaRootNode(initNode)) return;
+				const chainMethods = collectZodChainMethods(initNode).map((it) => it.name);
+				if ([
+					"parse",
+					"parseAsync",
+					"safeParse",
+					"safeParseAsync",
+					"spa",
+					"encode",
+					"encodeAsync",
+					"decode",
+					"decodeAsync",
+					"safeEncode",
+					"safeEncodeAsync",
+					"safeDecode",
+					"safeDecodeAsync",
+					"codec",
+					"treeifyError",
+					"prettifyError",
+					"formatError",
+					"flattenError"
+				].some((it) => chainMethods.includes(it))) return;
+				if (node.id.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier) return;
+				const { name } = node.id;
+				const validPrefix = !before || name.startsWith(before);
+				const validSuffix = !after || name.endsWith(after);
+				if (validPrefix && validSuffix) return;
+				const expected = (validPrefix ? "" : before) + name + (validSuffix ? "" : after);
+				context.report({
+					node,
+					messageId: "invalidName",
+					data: { expected }
+				});
+			}
+		};
+	}
+});
+//#endregion
+exports.consistentSchemaVarName = consistentSchemaVarName;

package/dist/rules/consistent-schema-var-name.mjs

@@ -0,0 +1,75 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.mjs";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region src/rules/consistent-schema-var-name.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("all");
+const consistentSchemaVarName = createZodPluginRule({
+	name: "consistent-schema-var-name",
+	meta: {
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Enforce a consistent naming convention for Zod schema variables"
+		},
+		messages: { invalidName: "Rename this Zod schema to \"{{expected}}\"" },
+		schema: [{
+			type: "object",
+			properties: {
+				before: {
+					type: "string",
+					description: "The required prefix for Zod schema variables"
+				},
+				after: {
+					type: "string",
+					description: "The required suffix for Zod schema variables"
+				}
+			},
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{ after: "Schema" }],
+	create(context, [{ before = "", after = "" }]) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			VariableDeclarator(node) {
+				const initNode = node.init;
+				if (initNode?.type !== AST_NODE_TYPES.CallExpression || !detectZodSchemaRootNode(initNode)) return;
+				const chainMethods = collectZodChainMethods(initNode).map((it) => it.name);
+				if ([
+					"parse",
+					"parseAsync",
+					"safeParse",
+					"safeParseAsync",
+					"spa",
+					"encode",
+					"encodeAsync",
+					"decode",
+					"decodeAsync",
+					"safeEncode",
+					"safeEncodeAsync",
+					"safeDecode",
+					"safeDecodeAsync",
+					"codec",
+					"treeifyError",
+					"prettifyError",
+					"formatError",
+					"flattenError"
+				].some((it) => chainMethods.includes(it))) return;
+				if (node.id.type !== AST_NODE_TYPES.Identifier) return;
+				const { name } = node.id;
+				const validPrefix = !before || name.startsWith(before);
+				const validSuffix = !after || name.endsWith(after);
+				if (validPrefix && validSuffix) return;
+				const expected = (validPrefix ? "" : before) + name + (validSuffix ? "" : after);
+				context.report({
+					node,
+					messageId: "invalidName",
+					data: { expected }
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { consistentSchemaVarName };

package/dist/rules/require-schema-suffix.cjs

@@ -8,6 +8,7 @@ const requireSchemaSuffix = require_create_plugin_rule.createZodPluginRule({
 	name: "require-schema-suffix",
 	meta: {
 		type: "suggestion",
+		deprecated: { message: "Use `zod/consistent-schema-var-name`" },
 		docs: {
 			zodImportAllowedSource,
 			description: "Require schema suffix when declaring a Zod schema"

package/dist/rules/require-schema-suffix.mjs

@@ -7,6 +7,7 @@ const requireSchemaSuffix = createZodPluginRule({
 	name: "require-schema-suffix",
 	meta: {
 		type: "suggestion",
+		deprecated: { message: "Use `zod/consistent-schema-var-name`" },
 		docs: {
 			zodImportAllowedSource,
 			description: "Require schema suffix when declaring a Zod schema"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-zod",
-  "version": "3.9.0",
+  "version": "3.11.0",
   "type": "module",
   "description": "ESLint plugin that adds custom linting rules to enforce best practices when using Zod",
   "engines": {