eslint-plugin-zod 3.0.2 → 3.2.0

package/README.md

@@ -26,27 +26,30 @@
 💼 Configurations enabled in.\
 ✅ Set in the `recommended` configuration.\
 🔧 Automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/user-guide/command-line-interface#--fix).\
-💡 Manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
-
-| Name                                                                               | Description                                                                                   | 💼  | 🔧  | 💡  |
-| :--------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------- | :-- | :-- | :-- |
-| [array-style](docs/rules/array-style.md)                                           | Enforce consistent Zod array style                                                            | ✅  | 🔧  |     |
-| [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-number-schema-with-int](docs/rules/no-number-schema-with-int.md)               | Disallow usage of `z.number().int()` as it is considered legacy                               | ✅  | 🔧  |     |
-| [no-optional-and-default-together](docs/rules/no-optional-and-default-together.md) | Disallow using both `.optional()` and `.default()` on the same Zod schema                     | ✅  | 🔧  |     |
-| [no-throw-in-refine](docs/rules/no-throw-in-refine.md)                             | Disallow throwing errors directly inside Zod refine callbacks                                 | ✅  |     |     |
-| [no-unknown-schema](docs/rules/no-unknown-schema.md)                               | Disallow usage of `z.unknown()` in Zod schemas                                                |     |     |     |
-| [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-meta](docs/rules/prefer-meta.md)                                           | Enforce usage of `.meta()` over `.describe()`                                                 | ✅  | 🔧  |     |
-| [prefer-meta-last](docs/rules/prefer-meta-last.md)                                 | Enforce `.meta()` as last method                                                              | ✅  | 🔧  |     |
-| [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) |     |     |     |
+💡 Manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).\
+❌ Deprecated.
+
+| Name                                                                               | Description                                                                                   | 💼  | 🔧  | 💡  | ❌  |
+| :--------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------- | :-- | :-- | :-- | :-- |
+| [array-style](docs/rules/array-style.md)                                           | Enforce consistent Zod array style                                                            | ✅  | 🔧  |     |     |
+| [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-number-schema-with-int](docs/rules/no-number-schema-with-int.md)               | Disallow usage of `z.number().int()` as it is considered legacy                               | ✅  | 🔧  |     |     |
+| [no-optional-and-default-together](docs/rules/no-optional-and-default-together.md) | Disallow using both `.optional()` and `.default()` on the same Zod schema                     | ✅  | 🔧  |     |     |
+| [no-string-schema-with-uuid](docs/rules/no-string-schema-with-uuid.md)             | Disallow usage of `z.string().uuid()` in favor of the dedicated `z.uuid()` schema             | ✅  | 🔧  |     |     |
+| [no-throw-in-refine](docs/rules/no-throw-in-refine.md)                             | Disallow throwing errors directly inside Zod refine callbacks                                 | ✅  |     |     |     |
+| [no-unknown-schema](docs/rules/no-unknown-schema.md)                               | Disallow usage of `z.unknown()` in Zod schemas                                                |     |     |     |     |
+| [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-meta](docs/rules/prefer-meta.md)                                           | Enforce usage of `.meta()` over `.describe()`                                                 | ✅  | 🔧  |     |     |
+| [prefer-meta-last](docs/rules/prefer-meta-last.md)                                 | Enforce `.meta()` as last method                                                              | ✅  | 🔧  |     |     |
+| [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) |     |     |     |     |
 
 <!-- end auto-generated rules list -->
 

package/dist/index.cjs

@@ -3,11 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const meta_js_1 = require("./meta.cjs");
 const array_style_js_1 = require("./rules/array-style.cjs");
 const consistent_import_source_js_1 = require("./rules/consistent-import-source.cjs");
+const consistent_import_js_1 = require("./rules/consistent-import.cjs");
 const consistent_object_schema_type_js_1 = require("./rules/consistent-object-schema-type.cjs");
 const no_any_schema_js_1 = require("./rules/no-any-schema.cjs");
 const no_empty_custom_schema_js_1 = require("./rules/no-empty-custom-schema.cjs");
 const no_number_schema_with_int_js_1 = require("./rules/no-number-schema-with-int.cjs");
 const no_optional_and_default_together_js_1 = require("./rules/no-optional-and-default-together.cjs");
+const no_string_schema_with_uuid_js_1 = require("./rules/no-string-schema-with-uuid.cjs");
 const no_throw_in_refine_js_1 = require("./rules/no-throw-in-refine.cjs");
 const no_unknown_schema_js_1 = require("./rules/no-unknown-schema.cjs");
 const prefer_enum_over_literal_union_js_1 = require("./rules/prefer-enum-over-literal-union.cjs");
@@ -26,10 +28,12 @@ const eslintPluginZod = {
     rules: {
         'array-style': array_style_js_1.arrayStyle,
         'consistent-import-source': consistent_import_source_js_1.consistentImportSource,
+        'consistent-import': consistent_import_js_1.consistentImport,
         'consistent-object-schema-type': consistent_object_schema_type_js_1.consistentObjectSchemaType,
         'no-any-schema': no_any_schema_js_1.noAnySchema,
         'no-empty-custom-schema': no_empty_custom_schema_js_1.noEmptyCustomSchema,
         'no-number-schema-with-int': no_number_schema_with_int_js_1.noNumberSchemaWithInt,
+        'no-string-schema-with-uuid': no_string_schema_with_uuid_js_1.noStringSchemaWithUuid,
         'no-optional-and-default-together': no_optional_and_default_together_js_1.noOptionalAndDefaultTogether,
         'no-throw-in-refine': no_throw_in_refine_js_1.noThrowInRefine,
         'no-unknown-schema': no_unknown_schema_js_1.noUnknownSchema,
@@ -51,15 +55,16 @@ const recommendedConfig = {
     },
     rules: {
         'zod/array-style': 'error',
+        'zod/consistent-import': 'error',
         'zod/no-any-schema': 'error',
         'zod/no-empty-custom-schema': 'error',
         'zod/no-number-schema-with-int': 'error',
+        'zod/no-string-schema-with-uuid': 'error',
         'zod/no-optional-and-default-together': 'error',
         'zod/no-throw-in-refine': 'error',
         'zod/prefer-enum-over-literal-union': 'error',
         'zod/prefer-meta': 'error',
         'zod/prefer-meta-last': 'error',
-        'zod/prefer-namespace-import': 'error',
         'zod/require-brand-type-parameter': 'error',
         'zod/require-error-message': 'error',
         'zod/require-schema-suffix': 'error',

package/dist/index.js

@@ -1,11 +1,13 @@
 import { PLUGIN_NAME, PLUGIN_VERSION } from "./meta.js";
 import { arrayStyle } from "./rules/array-style.js";
 import { consistentImportSource } from "./rules/consistent-import-source.js";
+import { consistentImport } from "./rules/consistent-import.js";
 import { consistentObjectSchemaType } from "./rules/consistent-object-schema-type.js";
 import { noAnySchema } from "./rules/no-any-schema.js";
 import { noEmptyCustomSchema } from "./rules/no-empty-custom-schema.js";
 import { noNumberSchemaWithInt } from "./rules/no-number-schema-with-int.js";
 import { noOptionalAndDefaultTogether } from "./rules/no-optional-and-default-together.js";
+import { noStringSchemaWithUuid } from "./rules/no-string-schema-with-uuid.js";
 import { noThrowInRefine } from "./rules/no-throw-in-refine.js";
 import { noUnknownSchema } from "./rules/no-unknown-schema.js";
 import { preferEnumOverLiteralUnion } from "./rules/prefer-enum-over-literal-union.js";
@@ -24,10 +26,12 @@ const eslintPluginZod = {
     rules: {
         'array-style': arrayStyle,
         'consistent-import-source': consistentImportSource,
+        'consistent-import': consistentImport,
         'consistent-object-schema-type': consistentObjectSchemaType,
         'no-any-schema': noAnySchema,
         'no-empty-custom-schema': noEmptyCustomSchema,
         'no-number-schema-with-int': noNumberSchemaWithInt,
+        'no-string-schema-with-uuid': noStringSchemaWithUuid,
         'no-optional-and-default-together': noOptionalAndDefaultTogether,
         'no-throw-in-refine': noThrowInRefine,
         'no-unknown-schema': noUnknownSchema,
@@ -49,15 +53,16 @@ const recommendedConfig = {
     },
     rules: {
         'zod/array-style': 'error',
+        'zod/consistent-import': 'error',
         'zod/no-any-schema': 'error',
         'zod/no-empty-custom-schema': 'error',
         'zod/no-number-schema-with-int': 'error',
+        'zod/no-string-schema-with-uuid': 'error',
         'zod/no-optional-and-default-together': 'error',
         'zod/no-throw-in-refine': 'error',
         'zod/prefer-enum-over-literal-union': 'error',
         'zod/prefer-meta': 'error',
         'zod/prefer-meta-last': 'error',
-        'zod/prefer-namespace-import': 'error',
         'zod/require-brand-type-parameter': 'error',
         'zod/require-error-message': 'error',
         'zod/require-schema-suffix': 'error',

package/dist/rules/consistent-import.cjs

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consistentImport = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const meta_js_1 = require("../meta.cjs");
+const is_zod_import_source_js_1 = require("../utils/is-zod-import-source.cjs");
+const IMPORT_SYNTAXES = ['namespace', 'named'];
+function isGroupFirstImportKindValidForSyntax(group, syntax) {
+    const { hasOnlyTypeImports, nodes } = group;
+    const [firstImportNode] = nodes;
+    const { specifiers, importKind } = firstImportNode;
+    if (specifiers.length !== 1) {
+        return false;
+    }
+    const [specifier] = specifiers;
+    const isValidForSyntax = syntax === 'named'
+        ? specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+            specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+            specifier.imported.name === 'z'
+        : specifier.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier;
+    if (!isValidForSyntax) {
+        return false;
+    }
+    if (hasOnlyTypeImports) {
+        return importKind === 'type';
+    }
+    return true;
+}
+function shouldIdentifierBeRenamed(node) {
+    if (node.parent.type === utils_1.AST_NODE_TYPES.ImportSpecifier) {
+        return false;
+    }
+    if (node.parent.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        node.parent.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+        node.parent.object.name !== node.name) {
+        return false;
+    }
+    return true;
+}
+function getNamespaceAliasNameFrom(node) {
+    if (node.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+        node.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+        return node.local.name;
+    }
+    if (node.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+        node.imported.name === 'z') {
+        return node.local.name;
+    }
+    return null;
+}
+exports.consistentImport = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+    name: 'consistent-import',
+    meta: {
+        type: 'problem',
+        docs: {
+            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 (!(0, is_zod_import_source_js_1.isZodImportSource)(source.value)) {
+                    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;
+                    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;
+                        }
+                    }
+                    const isFirstImportValid = isGroupFirstImportKindValidForSyntax(importGroup, syntax);
+                    if (!isFirstImportValid) {
+                        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 allVariables = nodesWithVariablesToUpdate.flatMap((it) => sourceCode.getDeclaredVariables(it));
+                    const allReferences = allVariables.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);
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/consistent-import.d.cts

@@ -0,0 +1,11 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const IMPORT_SYNTAXES: readonly ["namespace", "named"];
+type ImportSyntax = (typeof IMPORT_SYNTAXES)[number];
+interface Options {
+    syntax: ImportSyntax;
+}
+type MessageIds = 'changeImportSyntax' | 'removeDuplicate' | 'convertUsage';
+export declare const consistentImport: ESLintUtils.RuleModule<MessageIds, [Options], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export {};

package/dist/rules/consistent-import.d.ts

@@ -0,0 +1,11 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const IMPORT_SYNTAXES: readonly ["namespace", "named"];
+type ImportSyntax = (typeof IMPORT_SYNTAXES)[number];
+interface Options {
+    syntax: ImportSyntax;
+}
+type MessageIds = 'changeImportSyntax' | 'removeDuplicate' | 'convertUsage';
+export declare const consistentImport: ESLintUtils.RuleModule<MessageIds, [Options], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export {};

package/dist/rules/consistent-import.js

@@ -0,0 +1,175 @@
+import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
+import { getRuleURL } from "../meta.js";
+import { isZodImportSource } from "../utils/is-zod-import-source.js";
+const IMPORT_SYNTAXES = ['namespace', 'named'];
+function isGroupFirstImportKindValidForSyntax(group, syntax) {
+    const { hasOnlyTypeImports, nodes } = group;
+    const [firstImportNode] = nodes;
+    const { specifiers, importKind } = firstImportNode;
+    if (specifiers.length !== 1) {
+        return false;
+    }
+    const [specifier] = specifiers;
+    const isValidForSyntax = 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;
+    if (!isValidForSyntax) {
+        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;
+}
+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;
+}
+export const consistentImport = ESLintUtils.RuleCreator(getRuleURL)({
+    name: 'consistent-import',
+    meta: {
+        type: 'problem',
+        docs: {
+            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)) {
+                    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;
+                    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;
+                        }
+                    }
+                    const isFirstImportValid = isGroupFirstImportKindValidForSyntax(importGroup, syntax);
+                    if (!isFirstImportValid) {
+                        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 allVariables = nodesWithVariablesToUpdate.flatMap((it) => sourceCode.getDeclaredVariables(it));
+                    const allReferences = allVariables.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);
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-number-schema-with-int.cjs

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noNumberSchemaWithInt = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const meta_js_1 = require("../meta.cjs");
+const build_zod_chain_replacement_fix_js_1 = require("../utils/build-zod-chain-replacement-fix.cjs");
 const track_zod_schema_imports_js_1 = require("../utils/track-zod-schema-imports.cjs");
 exports.noNumberSchemaWithInt = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
     name: 'no-number-schema-with-int',
@@ -29,13 +30,11 @@ exports.noNumberSchemaWithInt = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRul
                     return;
                 }
                 const methods = collectZodChainMethods(node);
-                const numberIndex = methods.findIndex((m) => m.name === 'number');
                 const intIndex = methods.findIndex((m) => m.name === 'int');
-                if (numberIndex === -1 || intIndex === -1) {
+                if (intIndex === -1) {
                     return;
                 }
-                const numberNode = methods[numberIndex].node;
-                const intNode = methods[intIndex].node;
+                const numberIndex = methods.findIndex((m) => m.name === 'number');
                 if (zodSchemaMeta.schemaDecl === 'named') {
                     context.report({
                         node,
@@ -47,18 +46,14 @@ exports.noNumberSchemaWithInt = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRul
                     node,
                     messageId: 'removeNumber',
                     fix(fixer) {
-                        const numberCallee = numberNode.callee;
-                        const prefixObj = numberCallee.object;
-                        const prefixText = sourceCode.getText(prefixObj);
-                        const methodsBetween = methods.slice(numberIndex + 1, intIndex);
-                        const betweenSuffixes = methodsBetween.map((m) => {
-                            const callee = m.node.callee;
-                            const objText = sourceCode.getText(callee.object);
-                            const fullText = sourceCode.getText(m.node);
-                            return fullText.slice(objText.length);
+                        return (0, build_zod_chain_replacement_fix_js_1.buildZodChainReplacementFix)({
+                            sourceCode,
+                            fixer,
+                            methods,
+                            fromIndex: numberIndex,
+                            toIndex: intIndex,
+                            toMethodName: 'int',
                         });
-                        const replacement = `${prefixText}.int()${betweenSuffixes.join('')}`;
-                        return fixer.replaceTextRange([numberNode.range[0], intNode.range[1]], replacement);
                     },
                 });
             },

package/dist/rules/no-number-schema-with-int.js

@@ -1,5 +1,6 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
 import { getRuleURL } from "../meta.js";
+import { buildZodChainReplacementFix } from "../utils/build-zod-chain-replacement-fix.js";
 import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
 export const noNumberSchemaWithInt = ESLintUtils.RuleCreator(getRuleURL)({
     name: 'no-number-schema-with-int',
@@ -26,13 +27,11 @@ export const noNumberSchemaWithInt = ESLintUtils.RuleCreator(getRuleURL)({
                     return;
                 }
                 const methods = collectZodChainMethods(node);
-                const numberIndex = methods.findIndex((m) => m.name === 'number');
                 const intIndex = methods.findIndex((m) => m.name === 'int');
-                if (numberIndex === -1 || intIndex === -1) {
+                if (intIndex === -1) {
                     return;
                 }
-                const numberNode = methods[numberIndex].node;
-                const intNode = methods[intIndex].node;
+                const numberIndex = methods.findIndex((m) => m.name === 'number');
                 if (zodSchemaMeta.schemaDecl === 'named') {
                     context.report({
                         node,
@@ -44,18 +43,14 @@ export const noNumberSchemaWithInt = ESLintUtils.RuleCreator(getRuleURL)({
                     node,
                     messageId: 'removeNumber',
                     fix(fixer) {
-                        const numberCallee = numberNode.callee;
-                        const prefixObj = numberCallee.object;
-                        const prefixText = sourceCode.getText(prefixObj);
-                        const methodsBetween = methods.slice(numberIndex + 1, intIndex);
-                        const betweenSuffixes = methodsBetween.map((m) => {
-                            const callee = m.node.callee;
-                            const objText = sourceCode.getText(callee.object);
-                            const fullText = sourceCode.getText(m.node);
-                            return fullText.slice(objText.length);
+                        return buildZodChainReplacementFix({
+                            sourceCode,
+                            fixer,
+                            methods,
+                            fromIndex: numberIndex,
+                            toIndex: intIndex,
+                            toMethodName: 'int',
                         });
-                        const replacement = `${prefixText}.int()${betweenSuffixes.join('')}`;
-                        return fixer.replaceTextRange([numberNode.range[0], intNode.range[1]], replacement);
                     },
                 });
             },

package/dist/rules/no-string-schema-with-uuid.cjs

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noStringSchemaWithUuid = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const meta_js_1 = require("../meta.cjs");
+const build_zod_chain_replacement_fix_js_1 = require("../utils/build-zod-chain-replacement-fix.cjs");
+const track_zod_schema_imports_js_1 = require("../utils/track-zod-schema-imports.cjs");
+exports.noStringSchemaWithUuid = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+    name: 'no-string-schema-with-uuid',
+    meta: {
+        fixable: 'code',
+        type: 'problem',
+        docs: {
+            description: 'Disallow usage of `z.string().uuid()` in favor of the dedicated `z.uuid()` schema',
+            url: 'https://zod.dev/api#uuids',
+        },
+        messages: {
+            useUuid: '`z.string().uuid()` is redundant. Use `z.uuid()` instead.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const { sourceCode } = context;
+        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = (0, track_zod_schema_imports_js_1.trackZodSchemaImports)();
+        return {
+            ImportDeclaration: importDeclarationListener,
+            CallExpression(node) {
+                const zodSchemaMeta = detectZodSchemaRootNode(node);
+                if ((zodSchemaMeta === null || zodSchemaMeta === void 0 ? void 0 : zodSchemaMeta.schemaType) !== 'string') {
+                    return;
+                }
+                const methods = collectZodChainMethods(node);
+                const uuidIndex = methods.findIndex((m) => m.name === 'uuid');
+                if (uuidIndex === -1) {
+                    return;
+                }
+                const stringIndex = methods.findIndex((m) => m.name === 'string');
+                if (zodSchemaMeta.schemaDecl === 'named') {
+                    context.report({
+                        node,
+                        messageId: 'useUuid',
+                    });
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'useUuid',
+                    fix(fixer) {
+                        return (0, build_zod_chain_replacement_fix_js_1.buildZodChainReplacementFix)({
+                            sourceCode,
+                            fixer,
+                            methods,
+                            fromIndex: stringIndex,
+                            toIndex: uuidIndex,
+                            toMethodName: 'uuid',
+                        });
+                    },
+                });
+            },
+        };
+    },
+});

package/dist/rules/no-string-schema-with-uuid.d.cts

@@ -0,0 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const noStringSchemaWithUuid: ESLintUtils.RuleModule<"useUuid", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/dist/rules/no-string-schema-with-uuid.d.ts

@@ -0,0 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const noStringSchemaWithUuid: ESLintUtils.RuleModule<"useUuid", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/dist/rules/no-string-schema-with-uuid.js

@@ -0,0 +1,60 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { getRuleURL } from "../meta.js";
+import { buildZodChainReplacementFix } from "../utils/build-zod-chain-replacement-fix.js";
+import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
+export const noStringSchemaWithUuid = ESLintUtils.RuleCreator(getRuleURL)({
+    name: 'no-string-schema-with-uuid',
+    meta: {
+        fixable: 'code',
+        type: 'problem',
+        docs: {
+            description: 'Disallow usage of `z.string().uuid()` in favor of the dedicated `z.uuid()` schema',
+            url: 'https://zod.dev/api#uuids',
+        },
+        messages: {
+            useUuid: '`z.string().uuid()` is redundant. Use `z.uuid()` instead.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const { sourceCode } = 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) !== 'string') {
+                    return;
+                }
+                const methods = collectZodChainMethods(node);
+                const uuidIndex = methods.findIndex((m) => m.name === 'uuid');
+                if (uuidIndex === -1) {
+                    return;
+                }
+                const stringIndex = methods.findIndex((m) => m.name === 'string');
+                if (zodSchemaMeta.schemaDecl === 'named') {
+                    context.report({
+                        node,
+                        messageId: 'useUuid',
+                    });
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'useUuid',
+                    fix(fixer) {
+                        return buildZodChainReplacementFix({
+                            sourceCode,
+                            fixer,
+                            methods,
+                            fromIndex: stringIndex,
+                            toIndex: uuidIndex,
+                            toMethodName: 'uuid',
+                        });
+                    },
+                });
+            },
+        };
+    },
+});

package/dist/rules/prefer-namespace-import.cjs

@@ -46,6 +46,9 @@ exports.preferNamespaceImport = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRul
     name: 'prefer-namespace-import',
     meta: {
         type: 'suggestion',
+        deprecated: {
+            message: "Use `zod/consistent-import` with `{ syntax: 'namespace' }`",
+        },
         docs: {
             description: "Enforce importing zod as a namespace import (`import * as z from 'zod'`)",
         },

package/dist/rules/prefer-namespace-import.d.cts

@@ -1,4 +1,4 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const preferNamespaceImport: ESLintUtils.RuleModule<"useNamespace" | "removeDuplicate" | "convertUsage", [], unknown, ESLintUtils.RuleListener> & {
+export declare const preferNamespaceImport: ESLintUtils.RuleModule<"removeDuplicate" | "convertUsage" | "useNamespace", [], unknown, ESLintUtils.RuleListener> & {
     name: string;
 };

package/dist/rules/prefer-namespace-import.d.ts

@@ -1,4 +1,4 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const preferNamespaceImport: ESLintUtils.RuleModule<"useNamespace" | "removeDuplicate" | "convertUsage", [], unknown, ESLintUtils.RuleListener> & {
+export declare const preferNamespaceImport: ESLintUtils.RuleModule<"removeDuplicate" | "convertUsage" | "useNamespace", [], unknown, ESLintUtils.RuleListener> & {
     name: string;
 };

package/dist/rules/prefer-namespace-import.js

@@ -43,6 +43,9 @@ export const preferNamespaceImport = ESLintUtils.RuleCreator(getRuleURL)({
     name: 'prefer-namespace-import',
     meta: {
         type: 'suggestion',
+        deprecated: {
+            message: "Use `zod/consistent-import` with `{ syntax: 'namespace' }`",
+        },
         docs: {
             description: "Enforce importing zod as a namespace import (`import * as z from 'zod'`)",
         },

package/dist/utils/build-zod-chain-replacement-fix.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildZodChainReplacementFix = buildZodChainReplacementFix;
+function buildZodChainReplacementFix(opts) {
+    var _a, _b;
+    const { sourceCode, fixer, methods, fromIndex, toIndex, toMethodName } = opts;
+    const fromNode = (_a = methods[fromIndex]) === null || _a === void 0 ? void 0 : _a.node;
+    const toNode = (_b = methods[toIndex]) === null || _b === void 0 ? void 0 : _b.node;
+    if (!fromNode || !toNode) {
+        return null;
+    }
+    const fromCallee = fromNode.callee;
+    const prefixObj = fromCallee.object;
+    const prefixText = sourceCode.getText(prefixObj);
+    const methodsBetween = methods.slice(fromIndex + 1, toIndex);
+    const betweenSuffixes = methodsBetween.map((m) => {
+        const betweenCallee = m.node.callee;
+        const objText = sourceCode.getText(betweenCallee.object);
+        const fullText = sourceCode.getText(m.node);
+        return fullText.slice(objText.length);
+    });
+    const replacement = `${prefixText}.${toMethodName}()${betweenSuffixes.join('')}`;
+    return fixer.replaceTextRange([fromNode.range[0], toNode.range[1]], replacement);
+}

package/dist/utils/build-zod-chain-replacement-fix.d.cts

@@ -0,0 +1,12 @@
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+export declare function buildZodChainReplacementFix(opts: {
+    sourceCode: TSESLint.SourceCode;
+    fixer: TSESLint.RuleFixer;
+    methods: Array<{
+        name: string;
+        node: TSESTree.CallExpression;
+    }>;
+    fromIndex: number;
+    toIndex: number;
+    toMethodName: string;
+}): TSESLint.RuleFix | null;

package/dist/utils/build-zod-chain-replacement-fix.d.ts

@@ -0,0 +1,12 @@
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+export declare function buildZodChainReplacementFix(opts: {
+    sourceCode: TSESLint.SourceCode;
+    fixer: TSESLint.RuleFixer;
+    methods: Array<{
+        name: string;
+        node: TSESTree.CallExpression;
+    }>;
+    fromIndex: number;
+    toIndex: number;
+    toMethodName: string;
+}): TSESLint.RuleFix | null;

package/dist/utils/build-zod-chain-replacement-fix.js

@@ -0,0 +1,21 @@
+export function buildZodChainReplacementFix(opts) {
+    var _a, _b;
+    const { sourceCode, fixer, methods, fromIndex, toIndex, toMethodName } = opts;
+    const fromNode = (_a = methods[fromIndex]) === null || _a === void 0 ? void 0 : _a.node;
+    const toNode = (_b = methods[toIndex]) === null || _b === void 0 ? void 0 : _b.node;
+    if (!fromNode || !toNode) {
+        return null;
+    }
+    const fromCallee = fromNode.callee;
+    const prefixObj = fromCallee.object;
+    const prefixText = sourceCode.getText(prefixObj);
+    const methodsBetween = methods.slice(fromIndex + 1, toIndex);
+    const betweenSuffixes = methodsBetween.map((m) => {
+        const betweenCallee = m.node.callee;
+        const objText = sourceCode.getText(betweenCallee.object);
+        const fullText = sourceCode.getText(m.node);
+        return fullText.slice(objText.length);
+    });
+    const replacement = `${prefixText}.${toMethodName}()${betweenSuffixes.join('')}`;
+    return fixer.replaceTextRange([fromNode.range[0], toNode.range[1]], replacement);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-zod",
-  "version": "3.0.2",
+  "version": "3.2.0",
   "type": "module",
   "description": "ESLint plugin that adds custom linting rules to enforce best practices when using Zod",
   "engines": {
@@ -62,18 +62,20 @@
     "@marcalexiei/prettier-config": "1.1.4",
     "@types/esquery": "1.5.4",
     "@types/node": "24.10.1",
-    "@typescript-eslint/rule-tester": "8.51.0",
-    "@vitest/eslint-plugin": "1.6.4",
+    "@typescript-eslint/rule-tester": "8.56.1",
+    "@vitest/eslint-plugin": "1.6.9",
     "dedent": "1.7.1",
     "eslint": "9.39.2",
-    "eslint-doc-generator": "3.0.2",
-    "eslint-plugin-eslint-plugin": "7.2.0",
-    "eslint-plugin-n": "17.23.1",
-    "knip": "5.79.0",
-    "prettier": "3.7.4",
+    "eslint-doc-generator": "3.2.0",
+    "eslint-import-resolver-typescript": "4.4.4",
+    "eslint-plugin-eslint-plugin": "7.3.1",
+    "eslint-plugin-import-x": "4.16.1",
+    "eslint-plugin-n": "17.24.0",
+    "knip": "5.85.0",
+    "prettier": "3.8.1",
     "typescript": "5.9.3",
-    "typescript-eslint": "8.51.0",
-    "vitest": "4.0.16",
+    "typescript-eslint": "8.56.1",
+    "vitest": "4.0.18",
     "zshy": "0.7.0"
   },
   "scripts": {