eslint-plugin-zod 3.7.0 → 3.8.0

package/README.md

@@ -38,20 +38,21 @@ This plugin is primarily built for `zod`, so some rules are exclusive to `zod` a
 
 ### Universal rules (`zod` & `zod-mini`)
 
-| Name                                                                         | Description                                                                                   | 💼    | 🔧  | 💡  | ❌  |
-| :--------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------- | :---- | :-- | :-- | :-- |
-| [consistent-import](docs/rules/consistent-import.md)                         | Enforce a consistent import style for Zod                                                     | ✅    | 🔧  |     |     |
-| [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                                                |       |     | 💡  |     |
-| [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                                                |       |     |     |     |
-| [prefer-meta](docs/rules/prefer-meta.md)                                     | Enforce usage of `.meta()` over `.describe()`                                                 | ✅ ✔️ | 🔧  |     |     |
-| [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                                             | ✅ ✔️ |     |     |     |
-| [schema-error-property-style](docs/rules/schema-error-property-style.md)     | Enforce consistent style for error messages in Zod schema validation (using ESQuery patterns) |       |     |     |     |
+| Name                                                                                     | Description                                                                                   | 💼    | 🔧  | 💡  | ❌  |
+| :--------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------- | :---- | :-- | :-- | :-- |
+| [consistent-import](docs/rules/consistent-import.md)                                     | Enforce a consistent import style for Zod                                                     | ✅    | 🔧  |     |     |
+| [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                       |       | 🔧  |     |     |
+| [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                                                |       |     |     |     |
+| [prefer-meta](docs/rules/prefer-meta.md)                                                 | Enforce usage of `.meta()` over `.describe()`                                                 | ✅ ✔️ | 🔧  |     |     |
+| [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                                             | ✅ ✔️ |     |     |     |
+| [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

@@ -3,6 +3,7 @@ const require_array_style = require("./rules/array-style.cjs");
 const require_consistent_import_source = require("./rules/consistent-import-source.cjs");
 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_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_int = require("./rules/no-number-schema-with-int.cjs");
@@ -31,6 +32,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-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-number-schema-with-int": require_no_number_schema_with_int.noNumberSchemaWithInt,

package/dist/index.mjs

@@ -3,6 +3,7 @@ import { arrayStyle } from "./rules/array-style.mjs";
 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 { noAnySchema } from "./rules/no-any-schema.mjs";
 import { noEmptyCustomSchema } from "./rules/no-empty-custom-schema.mjs";
 import { noNumberSchemaWithInt } from "./rules/no-number-schema-with-int.mjs";
@@ -31,6 +32,7 @@ const eslintPluginZod = {
 		"consistent-import-source": consistentImportSource,
 		"consistent-import": consistentImport,
 		"consistent-object-schema-type": consistentObjectSchemaType,
+		"consistent-schema-output-type-style": consistentSchemaOutputTypeStyle,
 		"no-any-schema": noAnySchema,
 		"no-empty-custom-schema": noEmptyCustomSchema,
 		"no-number-schema-with-int": noNumberSchemaWithInt,

package/dist/rules/consistent-schema-output-type-style.cjs

@@ -0,0 +1,70 @@
+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-output-type-style.ts
+const ZOD_SCHEMA_TYPE_STYLES = ["infer", "output"];
+const { zodImportAllowedSource, trackZodSchemaImports } = require_track_zod_schema_imports.createZodSchemaImportTrack("all");
+const consistentSchemaOutputTypeStyle = require_create_plugin_rule.createZodPluginRule({
+	name: "consistent-schema-output-type-style",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: {
+			zodImportAllowedSource,
+			description: "Enforce consistent use of z.infer or z.output for schema type inference"
+		},
+		messages: {
+			useInfer: "Use infer instead of output.",
+			useOutput: "Use output instead of infer."
+		},
+		schema: [{
+			type: "object",
+			properties: { style: {
+				description: "Decides which style to use for schema type inference",
+				type: "string",
+				enum: [...ZOD_SCHEMA_TYPE_STYLES]
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{ style: "output" }],
+	create(context, [{ style }]) {
+		const { importDeclarationListener, isZodNamespace, getNamedImportOriginal, getNamedImportLocal } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			TSTypeReference(node) {
+				const { typeName } = node;
+				if (typeName.type === _typescript_eslint_utils.AST_NODE_TYPES.TSQualifiedName) {
+					const { left, right } = typeName;
+					if (left.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier || !isZodNamespace(left.name)) return;
+					const usedStyle = right.name;
+					if (usedStyle !== "infer" && usedStyle !== "output" || usedStyle === style) return;
+					context.report({
+						node: right,
+						messageId: style === "infer" ? "useInfer" : "useOutput",
+						fix(fixer) {
+							return fixer.replaceText(right, style);
+						}
+					});
+					return;
+				}
+				if (typeName.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier) {
+					const originalName = getNamedImportOriginal(typeName.name);
+					if (originalName !== "infer" && originalName !== "output" || originalName === style) return;
+					const targetLocalName = getNamedImportLocal(style);
+					context.report({
+						node: typeName,
+						messageId: style === "infer" ? "useInfer" : "useOutput",
+						fix(fixer) {
+							if (!targetLocalName || targetLocalName === "infer") return null;
+							return fixer.replaceText(typeName, targetLocalName);
+						}
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+exports.consistentSchemaOutputTypeStyle = consistentSchemaOutputTypeStyle;

package/dist/rules/consistent-schema-output-type-style.mjs

@@ -0,0 +1,69 @@
+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-output-type-style.ts
+const ZOD_SCHEMA_TYPE_STYLES = ["infer", "output"];
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("all");
+const consistentSchemaOutputTypeStyle = createZodPluginRule({
+	name: "consistent-schema-output-type-style",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: {
+			zodImportAllowedSource,
+			description: "Enforce consistent use of z.infer or z.output for schema type inference"
+		},
+		messages: {
+			useInfer: "Use infer instead of output.",
+			useOutput: "Use output instead of infer."
+		},
+		schema: [{
+			type: "object",
+			properties: { style: {
+				description: "Decides which style to use for schema type inference",
+				type: "string",
+				enum: [...ZOD_SCHEMA_TYPE_STYLES]
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{ style: "output" }],
+	create(context, [{ style }]) {
+		const { importDeclarationListener, isZodNamespace, getNamedImportOriginal, getNamedImportLocal } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			TSTypeReference(node) {
+				const { typeName } = node;
+				if (typeName.type === AST_NODE_TYPES.TSQualifiedName) {
+					const { left, right } = typeName;
+					if (left.type !== AST_NODE_TYPES.Identifier || !isZodNamespace(left.name)) return;
+					const usedStyle = right.name;
+					if (usedStyle !== "infer" && usedStyle !== "output" || usedStyle === style) return;
+					context.report({
+						node: right,
+						messageId: style === "infer" ? "useInfer" : "useOutput",
+						fix(fixer) {
+							return fixer.replaceText(right, style);
+						}
+					});
+					return;
+				}
+				if (typeName.type === AST_NODE_TYPES.Identifier) {
+					const originalName = getNamedImportOriginal(typeName.name);
+					if (originalName !== "infer" && originalName !== "output" || originalName === style) return;
+					const targetLocalName = getNamedImportLocal(style);
+					context.report({
+						node: typeName,
+						messageId: style === "infer" ? "useInfer" : "useOutput",
+						fix(fixer) {
+							if (!targetLocalName || targetLocalName === "infer") return null;
+							return fixer.replaceText(typeName, targetLocalName);
+						}
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+export { consistentSchemaOutputTypeStyle };

package/dist/utils/track-zod-schema-imports.cjs

@@ -9,7 +9,8 @@ let _typescript_eslint_utils = require("@typescript-eslint/utils");
 */
 function trackZodSchemaImports(importAllowedSource) {
 	const zodNamespaces = /* @__PURE__ */ new Set();
-	const zodNamedImports = /* @__PURE__ */ new Set();
+	const zodNamedImports = /* @__PURE__ */ new Map();
+	const zodNamedImportsByOriginal = /* @__PURE__ */ new Map();
 	function collectZodChainMethods(node) {
 		const methods = [];
 		let current = node;
@@ -42,12 +43,20 @@ function trackZodSchemaImports(importAllowedSource) {
 				case _typescript_eslint_utils.AST_NODE_TYPES.ImportNamespaceSpecifier:
 					zodNamespaces.add(spec.local.name);
 					break;
-				case _typescript_eslint_utils.AST_NODE_TYPES.ImportSpecifier:
-					if ("name" in spec.imported && spec.imported.name === "z") zodNamespaces.add(spec.local.name);
-					else zodNamedImports.add(spec.local.name);
+				case _typescript_eslint_utils.AST_NODE_TYPES.ImportSpecifier: {
+					const originalName = "name" in spec.imported ? spec.imported.name : spec.local.name;
+					if (originalName === "z") zodNamespaces.add(spec.local.name);
+					else {
+						zodNamedImports.set(spec.local.name, originalName);
+						zodNamedImportsByOriginal.set(originalName, spec.local.name);
+					}
 					break;
+				}
 			}
 		},
+		isZodNamespace: (name) => zodNamespaces.has(name),
+		getNamedImportOriginal: (localName) => zodNamedImports.get(localName),
+		getNamedImportLocal: (originalName) => zodNamedImportsByOriginal.get(originalName),
 		detectZodSchemaRootNode: (node) => require_detect_zod_schema_root_node.detectZodSchemaRootNode(node, zodNamespaces, zodNamedImports),
 		collectZodChainMethods
 	};

package/dist/utils/track-zod-schema-imports.mjs

@@ -8,7 +8,8 @@ import { AST_NODE_TYPES } from "@typescript-eslint/utils";
 */
 function trackZodSchemaImports(importAllowedSource) {
 	const zodNamespaces = /* @__PURE__ */ new Set();
-	const zodNamedImports = /* @__PURE__ */ new Set();
+	const zodNamedImports = /* @__PURE__ */ new Map();
+	const zodNamedImportsByOriginal = /* @__PURE__ */ new Map();
 	function collectZodChainMethods(node) {
 		const methods = [];
 		let current = node;
@@ -41,12 +42,20 @@ function trackZodSchemaImports(importAllowedSource) {
 				case AST_NODE_TYPES.ImportNamespaceSpecifier:
 					zodNamespaces.add(spec.local.name);
 					break;
-				case AST_NODE_TYPES.ImportSpecifier:
-					if ("name" in spec.imported && spec.imported.name === "z") zodNamespaces.add(spec.local.name);
-					else zodNamedImports.add(spec.local.name);
+				case AST_NODE_TYPES.ImportSpecifier: {
+					const originalName = "name" in spec.imported ? spec.imported.name : spec.local.name;
+					if (originalName === "z") zodNamespaces.add(spec.local.name);
+					else {
+						zodNamedImports.set(spec.local.name, originalName);
+						zodNamedImportsByOriginal.set(originalName, spec.local.name);
+					}
 					break;
+				}
 			}
 		},
+		isZodNamespace: (name) => zodNamespaces.has(name),
+		getNamedImportOriginal: (localName) => zodNamedImports.get(localName),
+		getNamedImportLocal: (originalName) => zodNamedImportsByOriginal.get(originalName),
 		detectZodSchemaRootNode: (node) => detectZodSchemaRootNode(node, zodNamespaces, zodNamedImports),
 		collectZodChainMethods
 	};

package/package.json

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