eslint-plugin-zod 3.5.1 → 3.5.2

package/dist/rules/consistent-import.mjs

@@ -0,0 +1,152 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { isZodImportSource } from "../utils/is-zod-import-source.mjs";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region src/rules/consistent-import.ts
+const IMPORT_SYNTAXES = ["namespace", "named"];
+/**
+* Determines whether the first import in a group is valid for a given import
+* syntax (`named` or `namespace`), taking into account whether the group
+* contains only type imports.
+*
+* Rules enforced:
+* - For `named` syntax:
+*   - The first import must have exactly one specifier
+*   - That specifier must be a named import of identifier `z`
+* - For `namespace` syntax:
+*   - The first import must have exactly one namespace specifier
+* - If the group contains only type imports, the first import must explicitly
+*   be declared as `import type`
+*
+* @param group - Metadata describing the import group
+* @param syntax - Expected import syntax for the group
+* @returns `true` if the first import matches the expected syntax and type rules
+*/
+function isGroupFirstImportKindValidForSyntax(group, syntax) {
+	const { hasOnlyTypeImports, nodes } = group;
+	const [firstImportNode] = nodes;
+	const { specifiers, importKind } = firstImportNode;
+	if (specifiers.length !== 1) return false;
+	const [specifier] = specifiers;
+	if (!(syntax === "named" ? specifier.type === AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES.Identifier && specifier.imported.name === "z" : specifier.type === AST_NODE_TYPES.ImportNamespaceSpecifier)) return false;
+	if (hasOnlyTypeImports) return importKind === "type";
+	return true;
+}
+function shouldIdentifierBeRenamed(node) {
+	if (node.parent.type === AST_NODE_TYPES.ImportSpecifier) return false;
+	if (node.parent.type === AST_NODE_TYPES.MemberExpression && node.parent.object.type === AST_NODE_TYPES.Identifier && node.parent.object.name !== node.name) return false;
+	return true;
+}
+/**
+* From a given specifiers retrieve the most significant to use when creating an alias import
+*/
+function getNamespaceAliasNameFrom(node) {
+	if (node.type === AST_NODE_TYPES.ImportDefaultSpecifier || node.type === AST_NODE_TYPES.ImportNamespaceSpecifier) return node.local.name;
+	if (node.imported.type === AST_NODE_TYPES.Identifier && node.imported.name === "z") return node.local.name;
+	return null;
+}
+const consistentImport = createZodPluginRule({
+	name: "consistent-import",
+	meta: {
+		type: "problem",
+		docs: {
+			zodImportAllowedSource: "all",
+			description: "Enforce a consistent import style for Zod"
+		},
+		fixable: "code",
+		messages: {
+			changeImportSyntax: "Use a {{syntax}} import for Zod.",
+			removeDuplicate: "Remove duplicate Zod import; Zod is already imported.",
+			convertUsage: "Update Zod usage to match the {{syntax}} import syntax."
+		},
+		schema: [{
+			type: "object",
+			properties: { syntax: {
+				description: "Specifies the import syntax to use for Zod.",
+				type: "string",
+				enum: IMPORT_SYNTAXES
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{ syntax: "namespace" }],
+	create(context, [options]) {
+		const { syntax } = options;
+		const { sourceCode } = context;
+		const importGroups = {};
+		return {
+			ImportDeclaration(node) {
+				const { source, importKind } = node;
+				if (!isZodImportSource(source.value, "all")) return;
+				if (!importGroups[source.value]) importGroups[source.value] = {
+					hasOnlyTypeImports: true,
+					nodes: []
+				};
+				if (importGroups[source.value].hasOnlyTypeImports && importKind === "value") importGroups[source.value].hasOnlyTypeImports = false;
+				importGroups[source.value].nodes.push(node);
+			},
+			"Program:exit": function() {
+				let namespaceAliasNameIndex = 0;
+				for (const importGroup of Object.values(importGroups)) {
+					const { hasOnlyTypeImports, nodes } = importGroup;
+					const [firstImportNode, ...othersImportNodes] = nodes;
+					/**
+					* Variable to track all specifiers that later are used by {@link getDeclaredVariables}
+					* to add the namespace prefix
+					*/
+					const nodesWithVariablesToUpdate = [];
+					let namespaceAliasName = null;
+					for (const specifier of nodes.flatMap((it) => it.specifiers)) {
+						if (!namespaceAliasName) {
+							namespaceAliasName = getNamespaceAliasNameFrom(specifier);
+							if (namespaceAliasName) continue;
+						}
+						nodesWithVariablesToUpdate.push(specifier);
+					}
+					if (!namespaceAliasName) {
+						namespaceAliasName = "z";
+						if (namespaceAliasNameIndex > 0) {
+							namespaceAliasName = `z${namespaceAliasNameIndex}`;
+							namespaceAliasNameIndex += 1;
+						}
+					}
+					if (!isGroupFirstImportKindValidForSyntax(importGroup, syntax)) context.report({
+						node: firstImportNode,
+						messageId: "changeImportSyntax",
+						data: { syntax },
+						fix(fixer) {
+							const importTypeKeyword = hasOnlyTypeImports ? "type " : "";
+							let importSpecifier;
+							if (syntax === "named") if (namespaceAliasName === "z") importSpecifier = "{ z }";
+							else importSpecifier = `{ z as ${namespaceAliasName} }`;
+							else importSpecifier = `* as ${namespaceAliasName}`;
+							const newImportText = `import ${importTypeKeyword}${importSpecifier} from ${firstImportNode.source.raw};`;
+							return fixer.replaceText(firstImportNode, newImportText);
+						}
+					});
+					const allReferences = nodesWithVariablesToUpdate.flatMap((it) => sourceCode.getDeclaredVariables(it)).flatMap((it) => it.references);
+					for (const ref of allReferences) {
+						const { identifier } = ref;
+						if (shouldIdentifierBeRenamed(identifier)) context.report({
+							node: identifier,
+							messageId: "convertUsage",
+							data: { syntax },
+							fix(fixer) {
+								const newId = `${namespaceAliasName}.${identifier.name}`;
+								return fixer.replaceText(identifier, newId);
+							}
+						});
+					}
+					for (const extraImport of othersImportNodes) context.report({
+						node: extraImport,
+						messageId: "removeDuplicate",
+						fix(fixer) {
+							return fixer.removeRange(extraImport.range);
+						}
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+export { consistentImport };

package/dist/rules/consistent-object-schema-type.cjs

@@ -1,85 +1,82 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.consistentObjectSchemaType = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-const create_plugin_rule_js_1 = require("../utils/create-plugin-rule.cjs");
-const track_zod_schema_imports_js_1 = require("../utils/track-zod-schema-imports.cjs");
-const ZOD_OBJECT_METHODS = ['object', 'looseObject', 'strictObject'];
-const defaultOptions = { allow: ['object'] };
-const { zodImportAllowedSource, trackZodSchemaImports, } = (0, track_zod_schema_imports_js_1.createZodSchemaImportTrack)('all');
-exports.consistentObjectSchemaType = (0, create_plugin_rule_js_1.createZodPluginRule)({
-    name: 'consistent-object-schema-type',
-    meta: {
-        hasSuggestions: true,
-        type: 'suggestion',
-        docs: {
-            zodImportAllowedSource,
-            description: 'Enforce consistent usage of Zod schema methods',
-        },
-        messages: {
-            consistentMethod: "Inconsistent Zod object schema method '{{actual}}'. Allowed: {{allowedList}}.",
-            useMethod: "Replace with '{{expected}}'.",
-        },
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    allow: {
-                        type: 'array',
-                        description: 'Decides which object methods are allowed',
-                        items: {
-                            type: 'string',
-                            enum: [...ZOD_OBJECT_METHODS],
-                        },
-                        minItems: 1,
-                        uniqueItems: true,
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-    },
-    defaultOptions: [defaultOptions],
-    create(context, [{ allow: allowedList }]) {
-        const { importDeclarationListener, detectZodSchemaRootNode, } = trackZodSchemaImports();
-        return {
-            ImportDeclaration: importDeclarationListener,
-            CallExpression(node) {
-                const zodSchemaMeta = detectZodSchemaRootNode(node);
-                const schemaType = zodSchemaMeta === null || zodSchemaMeta === void 0 ? void 0 : zodSchemaMeta.schemaType;
-                if (!schemaType || !ZOD_OBJECT_METHODS.includes(schemaType)) {
-                    return;
-                }
-                if (allowedList.includes(schemaType)) {
-                    return;
-                }
-                const { callee } = node;
-                if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    context.report({
-                        node,
-                        messageId: 'consistentMethod',
-                        data: { actual: schemaType, allowedList: allowedList.join(',') },
-                    });
-                    return;
-                }
-                if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                    context.report({
-                        node,
-                        messageId: 'consistentMethod',
-                        data: {
-                            actual: schemaType,
-                            allowedList: allowedList.join(','),
-                        },
-                        suggest: allowedList.map((it) => ({
-                            messageId: 'useMethod',
-                            data: { expected: it },
-                            fix(fixer) {
-                                return fixer.replaceText(callee.property, it);
-                            },
-                        })),
-                    });
-                }
-            },
-        };
-    },
+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-object-schema-type.ts
+const ZOD_OBJECT_METHODS = [
+	"object",
+	"looseObject",
+	"strictObject"
+];
+const defaultOptions = { allow: ["object"] };
+const { zodImportAllowedSource, trackZodSchemaImports } = require_track_zod_schema_imports.createZodSchemaImportTrack("all");
+const consistentObjectSchemaType = require_create_plugin_rule.createZodPluginRule({
+	name: "consistent-object-schema-type",
+	meta: {
+		hasSuggestions: true,
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Enforce consistent usage of Zod schema methods"
+		},
+		messages: {
+			consistentMethod: "Inconsistent Zod object schema method '{{actual}}'. Allowed: {{allowedList}}.",
+			useMethod: "Replace with '{{expected}}'."
+		},
+		schema: [{
+			type: "object",
+			properties: { allow: {
+				type: "array",
+				description: "Decides which object methods are allowed",
+				items: {
+					type: "string",
+					enum: [...ZOD_OBJECT_METHODS]
+				},
+				minItems: 1,
+				uniqueItems: true
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [defaultOptions],
+	create(context, [{ allow: allowedList }]) {
+		const { importDeclarationListener, detectZodSchemaRootNode } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const schemaType = detectZodSchemaRootNode(node)?.schemaType;
+				if (!schemaType || !ZOD_OBJECT_METHODS.includes(schemaType)) return;
+				if (allowedList.includes(schemaType)) return;
+				const { callee } = node;
+				if (callee.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier) {
+					context.report({
+						node,
+						messageId: "consistentMethod",
+						data: {
+							actual: schemaType,
+							allowedList: allowedList.join(",")
+						}
+					});
+					return;
+				}
+				if (callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) context.report({
+					node,
+					messageId: "consistentMethod",
+					data: {
+						actual: schemaType,
+						allowedList: allowedList.join(",")
+					},
+					suggest: allowedList.map((it) => ({
+						messageId: "useMethod",
+						data: { expected: it },
+						fix(fixer) {
+							return fixer.replaceText(callee.property, it);
+						}
+					}))
+				});
+			}
+		};
+	}
 });
+//#endregion
+exports.consistentObjectSchemaType = consistentObjectSchemaType;

package/dist/rules/consistent-object-schema-type.mjs

@@ -0,0 +1,81 @@
+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-object-schema-type.ts
+const ZOD_OBJECT_METHODS = [
+	"object",
+	"looseObject",
+	"strictObject"
+];
+const defaultOptions = { allow: ["object"] };
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("all");
+const consistentObjectSchemaType = createZodPluginRule({
+	name: "consistent-object-schema-type",
+	meta: {
+		hasSuggestions: true,
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Enforce consistent usage of Zod schema methods"
+		},
+		messages: {
+			consistentMethod: "Inconsistent Zod object schema method '{{actual}}'. Allowed: {{allowedList}}.",
+			useMethod: "Replace with '{{expected}}'."
+		},
+		schema: [{
+			type: "object",
+			properties: { allow: {
+				type: "array",
+				description: "Decides which object methods are allowed",
+				items: {
+					type: "string",
+					enum: [...ZOD_OBJECT_METHODS]
+				},
+				minItems: 1,
+				uniqueItems: true
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [defaultOptions],
+	create(context, [{ allow: allowedList }]) {
+		const { importDeclarationListener, detectZodSchemaRootNode } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const schemaType = detectZodSchemaRootNode(node)?.schemaType;
+				if (!schemaType || !ZOD_OBJECT_METHODS.includes(schemaType)) return;
+				if (allowedList.includes(schemaType)) return;
+				const { callee } = node;
+				if (callee.type === AST_NODE_TYPES.Identifier) {
+					context.report({
+						node,
+						messageId: "consistentMethod",
+						data: {
+							actual: schemaType,
+							allowedList: allowedList.join(",")
+						}
+					});
+					return;
+				}
+				if (callee.type === AST_NODE_TYPES.MemberExpression) context.report({
+					node,
+					messageId: "consistentMethod",
+					data: {
+						actual: schemaType,
+						allowedList: allowedList.join(",")
+					},
+					suggest: allowedList.map((it) => ({
+						messageId: "useMethod",
+						data: { expected: it },
+						fix(fixer) {
+							return fixer.replaceText(callee.property, it);
+						}
+					}))
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { consistentObjectSchemaType };

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

@@ -1,68 +1,63 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.noAnySchema = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-const create_plugin_rule_js_1 = require("../utils/create-plugin-rule.cjs");
-const track_zod_schema_imports_js_1 = require("../utils/track-zod-schema-imports.cjs");
-const { zodImportAllowedSource, trackZodSchemaImports, } = (0, track_zod_schema_imports_js_1.createZodSchemaImportTrack)('all');
-exports.noAnySchema = (0, create_plugin_rule_js_1.createZodPluginRule)({
-    name: 'no-any-schema',
-    meta: {
-        hasSuggestions: true,
-        type: 'suggestion',
-        docs: {
-            zodImportAllowedSource,
-            description: 'Disallow usage of `z.any()` in Zod schemas',
-        },
-        messages: {
-            noZAny: 'Using `z.any()` is not allowed. Please use a more specific schema.',
-            useUnknown: 'Replace `z.any()` with `z.unknown()`',
-        },
-        schema: [],
-    },
-    defaultOptions: [],
-    create(context) {
-        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
-        return {
-            ImportDeclaration: importDeclarationListener,
-            CallExpression(node) {
-                const zodSchemaMeta = detectZodSchemaRootNode(node);
-                if ((zodSchemaMeta === null || zodSchemaMeta === void 0 ? void 0 : zodSchemaMeta.schemaType) !== 'any') {
-                    return;
-                }
-                const { callee } = node;
-                if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    context.report({
-                        node,
-                        messageId: 'noZAny',
-                    });
-                    return;
-                }
-                if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                    const [{ node: schemaMethod }] = collectZodChainMethods(node);
-                    const schemaMethodCallee = schemaMethod.callee;
-                    if (schemaMethodCallee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                        schemaMethodCallee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
-                        context.report({
-                            node,
-                            messageId: 'noZAny',
-                            suggest: [
-                                {
-                                    messageId: 'useUnknown',
-                                    fix(fixer) {
-                                        return fixer.replaceText(schemaMethodCallee.property, 'unknown');
-                                    },
-                                },
-                            ],
-                        });
-                        return;
-                    }
-                    context.report({
-                        node,
-                        messageId: 'noZAny',
-                    });
-                }
-            },
-        };
-    },
+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/no-any-schema.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = require_track_zod_schema_imports.createZodSchemaImportTrack("all");
+const noAnySchema = require_create_plugin_rule.createZodPluginRule({
+	name: "no-any-schema",
+	meta: {
+		hasSuggestions: true,
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Disallow usage of `z.any()` in Zod schemas"
+		},
+		messages: {
+			noZAny: "Using `z.any()` is not allowed. Please use a more specific schema.",
+			useUnknown: "Replace `z.any()` with `z.unknown()`"
+		},
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				if (detectZodSchemaRootNode(node)?.schemaType !== "any") return;
+				const { callee } = node;
+				if (callee.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier) {
+					context.report({
+						node,
+						messageId: "noZAny"
+					});
+					return;
+				}
+				if (callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) {
+					const [{ node: schemaMethod }] = collectZodChainMethods(node);
+					const schemaMethodCallee = schemaMethod.callee;
+					if (schemaMethodCallee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && schemaMethodCallee.property.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier) {
+						context.report({
+							node,
+							messageId: "noZAny",
+							suggest: [{
+								messageId: "useUnknown",
+								fix(fixer) {
+									return fixer.replaceText(schemaMethodCallee.property, "unknown");
+								}
+							}]
+						});
+						return;
+					}
+					context.report({
+						node,
+						messageId: "noZAny"
+					});
+				}
+			}
+		};
+	}
 });
+//#endregion
+exports.noAnySchema = noAnySchema;

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

@@ -0,0 +1,62 @@
+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/no-any-schema.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("all");
+const noAnySchema = createZodPluginRule({
+	name: "no-any-schema",
+	meta: {
+		hasSuggestions: true,
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Disallow usage of `z.any()` in Zod schemas"
+		},
+		messages: {
+			noZAny: "Using `z.any()` is not allowed. Please use a more specific schema.",
+			useUnknown: "Replace `z.any()` with `z.unknown()`"
+		},
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				if (detectZodSchemaRootNode(node)?.schemaType !== "any") return;
+				const { callee } = node;
+				if (callee.type === AST_NODE_TYPES.Identifier) {
+					context.report({
+						node,
+						messageId: "noZAny"
+					});
+					return;
+				}
+				if (callee.type === AST_NODE_TYPES.MemberExpression) {
+					const [{ node: schemaMethod }] = collectZodChainMethods(node);
+					const schemaMethodCallee = schemaMethod.callee;
+					if (schemaMethodCallee.type === AST_NODE_TYPES.MemberExpression && schemaMethodCallee.property.type === AST_NODE_TYPES.Identifier) {
+						context.report({
+							node,
+							messageId: "noZAny",
+							suggest: [{
+								messageId: "useUnknown",
+								fix(fixer) {
+									return fixer.replaceText(schemaMethodCallee.property, "unknown");
+								}
+							}]
+						});
+						return;
+					}
+					context.report({
+						node,
+						messageId: "noZAny"
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+export { noAnySchema };