eslint-plugin-zod 3.2.0 → 3.3.0

package/README.md

@@ -46,6 +46,7 @@
 | [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

@@ -16,6 +16,7 @@ const prefer_enum_over_literal_union_js_1 = require("./rules/prefer-enum-over-li
 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");
@@ -41,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,
@@ -65,6 +67,7 @@ const recommendedConfig = {
         '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

@@ -14,6 +14,7 @@ import { preferEnumOverLiteralUnion } from "./rules/prefer-enum-over-literal-uni
 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";
@@ -39,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,
@@ -63,6 +65,7 @@ const recommendedConfig = {
         '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-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/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

@@ -19,6 +19,13 @@ function buildZodChainReplacementFix(opts) {
         const fullText = sourceCode.getText(m.node);
         return fullText.slice(objText.length);
     });
-    const replacement = `${prefixText}.${toMethodName}()${betweenSuffixes.join('')}`;
+    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.js

@@ -16,6 +16,13 @@ export function buildZodChainReplacementFix(opts) {
         const fullText = sourceCode.getText(m.node);
         return fullText.slice(objText.length);
     });
-    const replacement = `${prefixText}.${toMethodName}()${betweenSuffixes.join('')}`;
+    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.2.0",
+  "version": "3.3.0",
   "type": "module",
   "description": "ESLint plugin that adds custom linting rules to enforce best practices when using Zod",
   "engines": {