eslint-plugin-zod 3.1.0 → 3.3.0

package/README.md

@@ -39,12 +39,14 @@
 | [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'`)                      |     | 🔧  |     | ❌  |
+| [prefer-string-schema-with-trim](docs/rules/prefer-string-schema-with-trim.md)     | Enforce `z.string().trim()` to prevent accidental leading/trailing whitespace                 | ✅  | 🔧  |     |     |
 | [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                                             | ✅  |     |     |     |

package/dist/index.cjs

@@ -9,12 +9,14 @@ 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");
 const prefer_meta_last_js_1 = require("./rules/prefer-meta-last.cjs");
 const prefer_meta_js_1 = require("./rules/prefer-meta.cjs");
 const prefer_namespace_import_js_1 = require("./rules/prefer-namespace-import.cjs");
+const prefer_string_schema_with_trim_js_1 = require("./rules/prefer-string-schema-with-trim.cjs");
 const require_brand_type_parameter_js_1 = require("./rules/require-brand-type-parameter.cjs");
 const require_error_message_js_1 = require("./rules/require-error-message.cjs");
 const require_schema_suffix_js_1 = require("./rules/require-schema-suffix.cjs");
@@ -32,6 +34,7 @@ const eslintPluginZod = {
         '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,
@@ -39,6 +42,7 @@ const eslintPluginZod = {
         'prefer-meta': prefer_meta_js_1.preferMeta,
         'prefer-meta-last': prefer_meta_last_js_1.preferMetaLast,
         'prefer-namespace-import': prefer_namespace_import_js_1.preferNamespaceImport,
+        'prefer-string-schema-with-trim': prefer_string_schema_with_trim_js_1.preferStringSchemaWithTrim,
         'require-brand-type-parameter': require_brand_type_parameter_js_1.requireBrandTypeParameter,
         'require-error-message': require_error_message_js_1.requireErrorMessage,
         'require-schema-suffix': require_schema_suffix_js_1.requireSchemaSuffix,
@@ -57,11 +61,13 @@ const recommendedConfig = {
         '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-string-schema-with-trim': 'error',
         'zod/require-brand-type-parameter': 'error',
         'zod/require-error-message': 'error',
         'zod/require-schema-suffix': 'error',

package/dist/index.js

@@ -7,12 +7,14 @@ 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";
 import { preferMetaLast } from "./rules/prefer-meta-last.js";
 import { preferMeta } from "./rules/prefer-meta.js";
 import { preferNamespaceImport } from "./rules/prefer-namespace-import.js";
+import { preferStringSchemaWithTrim } from "./rules/prefer-string-schema-with-trim.js";
 import { requireBrandTypeParameter } from "./rules/require-brand-type-parameter.js";
 import { requireErrorMessage } from "./rules/require-error-message.js";
 import { requireSchemaSuffix } from "./rules/require-schema-suffix.js";
@@ -30,6 +32,7 @@ const eslintPluginZod = {
         '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,
@@ -37,6 +40,7 @@ const eslintPluginZod = {
         'prefer-meta': preferMeta,
         'prefer-meta-last': preferMetaLast,
         'prefer-namespace-import': preferNamespaceImport,
+        'prefer-string-schema-with-trim': preferStringSchemaWithTrim,
         'require-brand-type-parameter': requireBrandTypeParameter,
         'require-error-message': requireErrorMessage,
         'require-schema-suffix': requireSchemaSuffix,
@@ -55,11 +59,13 @@ const recommendedConfig = {
         '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-string-schema-with-trim': 'error',
         'zod/require-brand-type-parameter': 'error',
         'zod/require-error-message': 'error',
         'zod/require-schema-suffix': 'error',

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-optional-and-default-together.cjs

@@ -35,11 +35,11 @@ exports.noOptionalAndDefaultTogether = utils_1.ESLintUtils.RuleCreator(meta_js_1
     defaultOptions: [defaultOptions],
     create(context, [{ preferredMethod }]) {
         const { sourceCode } = context;
-        const { importDeclarationListener, detectZodSchemaRootNode: isZodSchema, collectZodChainMethods, } = (0, track_zod_schema_imports_js_1.trackZodSchemaImports)();
+        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = (0, track_zod_schema_imports_js_1.trackZodSchemaImports)();
         return {
             ImportDeclaration: importDeclarationListener,
             CallExpression(node) {
-                if (!isZodSchema(node)) {
+                if (!detectZodSchemaRootNode(node)) {
                     return;
                 }
                 const methods = collectZodChainMethods(node);

package/dist/rules/no-optional-and-default-together.js

@@ -32,11 +32,11 @@ export const noOptionalAndDefaultTogether = ESLintUtils.RuleCreator(getRuleURL)(
     defaultOptions: [defaultOptions],
     create(context, [{ preferredMethod }]) {
         const { sourceCode } = context;
-        const { importDeclarationListener, detectZodSchemaRootNode: isZodSchema, collectZodChainMethods, } = trackZodSchemaImports();
+        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
         return {
             ImportDeclaration: importDeclarationListener,
             CallExpression(node) {
-                if (!isZodSchema(node)) {
+                if (!detectZodSchemaRootNode(node)) {
                     return;
                 }
                 const methods = collectZodChainMethods(node);

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-string-schema-with-trim.cjs

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferStringSchemaWithTrim = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const meta_js_1 = require("../meta.cjs");
+const track_zod_schema_imports_js_1 = require("../utils/track-zod-schema-imports.cjs");
+exports.preferStringSchemaWithTrim = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+    name: 'prefer-string-schema-with-trim',
+    meta: {
+        type: 'problem',
+        fixable: 'code',
+        docs: {
+            description: 'Enforce `z.string().trim()` to prevent accidental leading/trailing whitespace',
+        },
+        messages: {
+            addTrim: '`z.string()` schemas should use `.trim()`.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(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(zodSchemaMeta.node);
+                if (methods.some((it) => it.name === 'trim')) {
+                    return;
+                }
+                if (zodSchemaMeta.schemaDecl === 'named') {
+                    context.report({
+                        node,
+                        messageId: 'addTrim',
+                    });
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'addTrim',
+                    fix(fixer) {
+                        const lastMethod = methods.at(0);
+                        return fixer.insertTextAfter(lastMethod.node, '.trim()');
+                    },
+                });
+            },
+        };
+    },
+});

package/dist/rules/prefer-string-schema-with-trim.d.cts

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

package/dist/rules/prefer-string-schema-with-trim.d.ts

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

package/dist/rules/prefer-string-schema-with-trim.js

@@ -0,0 +1,49 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { getRuleURL } from "../meta.js";
+import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
+export const preferStringSchemaWithTrim = ESLintUtils.RuleCreator(getRuleURL)({
+    name: 'prefer-string-schema-with-trim',
+    meta: {
+        type: 'problem',
+        fixable: 'code',
+        docs: {
+            description: 'Enforce `z.string().trim()` to prevent accidental leading/trailing whitespace',
+        },
+        messages: {
+            addTrim: '`z.string()` schemas should use `.trim()`.',
+        },
+        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) !== 'string') {
+                    return;
+                }
+                const methods = collectZodChainMethods(zodSchemaMeta.node);
+                if (methods.some((it) => it.name === 'trim')) {
+                    return;
+                }
+                if (zodSchemaMeta.schemaDecl === 'named') {
+                    context.report({
+                        node,
+                        messageId: 'addTrim',
+                    });
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'addTrim',
+                    fix(fixer) {
+                        const lastMethod = methods.at(0);
+                        return fixer.insertTextAfter(lastMethod.node, '.trim()');
+                    },
+                });
+            },
+        };
+    },
+});

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

@@ -0,0 +1,31 @@
+"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);
+    });
+    let replacement = `${prefixText}.${toMethodName}(`;
+    if (toNode.arguments.length) {
+        const argsText = toNode.arguments
+            .map((arg) => sourceCode.getText(arg))
+            .join(', ');
+        replacement += argsText;
+    }
+    replacement += `)${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,28 @@
+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);
+    });
+    let replacement = `${prefixText}.${toMethodName}(`;
+    if (toNode.arguments.length) {
+        const argsText = toNode.arguments
+            .map((arg) => sourceCode.getText(arg))
+            .join(', ');
+        replacement += argsText;
+    }
+    replacement += `)${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.1.0",
+  "version": "3.3.0",
   "type": "module",
   "description": "ESLint plugin that adds custom linting rules to enforce best practices when using Zod",
   "engines": {
@@ -62,19 +62,19 @@
     "@marcalexiei/prettier-config": "1.1.4",
     "@types/esquery": "1.5.4",
     "@types/node": "24.10.1",
-    "@typescript-eslint/rule-tester": "8.54.0",
-    "@vitest/eslint-plugin": "1.6.6",
+    "@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-doc-generator": "3.2.0",
     "eslint-import-resolver-typescript": "4.4.4",
-    "eslint-plugin-eslint-plugin": "7.3.0",
+    "eslint-plugin-eslint-plugin": "7.3.1",
     "eslint-plugin-import-x": "4.16.1",
-    "eslint-plugin-n": "17.23.2",
-    "knip": "5.83.0",
+    "eslint-plugin-n": "17.24.0",
+    "knip": "5.85.0",
     "prettier": "3.8.1",
     "typescript": "5.9.3",
-    "typescript-eslint": "8.54.0",
+    "typescript-eslint": "8.56.1",
     "vitest": "4.0.18",
     "zshy": "0.7.0"
   },