eslint-plugin-zod 1.3.0 → 3.0.0

package/dist/rules/require-brand-type-parameter.cjs

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireBrandTypeParameter = 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.requireBrandTypeParameter = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+    name: 'require-brand-type-parameter',
+    meta: {
+        hasSuggestions: true,
+        type: 'problem',
+        docs: {
+            description: 'Require type parameter on `.brand()` functions',
+        },
+        messages: {
+            missingTypeParameter: 'Type parameter is required when using `.brand()`',
+            removeBrandFunction: 'Brand is a static-only construct. If not parameter is required consider removal',
+        },
+        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) {
+                    return;
+                }
+                const methods = collectZodChainMethods(zodSchemaMeta.node);
+                const brandMethod = methods.find((it) => it.name === 'brand');
+                if (!brandMethod) {
+                    return;
+                }
+                const brandNode = brandMethod.node;
+                const { typeArguments } = brandNode;
+                if (typeArguments && typeArguments.params.length > 0) {
+                    return;
+                }
+                const brandCalleeNode = brandNode.callee;
+                context.report({
+                    messageId: 'missingTypeParameter',
+                    node: brandCalleeNode.property,
+                    suggest: [
+                        {
+                            messageId: 'removeBrandFunction',
+                            fix(fixer) {
+                                return fixer.removeRange([
+                                    brandCalleeNode.object.range[1],
+                                    brandNode.range[1],
+                                ]);
+                            },
+                        },
+                    ],
+                });
+            },
+        };
+    },
+});

package/dist/rules/require-brand-type-parameter.d.cts

@@ -0,0 +1,4 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export declare const requireBrandTypeParameter: TSESLint.RuleModule<"missingTypeParameter" | "removeBrandFunction", [], unknown, TSESLint.RuleListener> & {
+    name: string;
+};

package/dist/rules/require-brand-type-parameter.d.ts

@@ -0,0 +1,4 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export declare const requireBrandTypeParameter: TSESLint.RuleModule<"missingTypeParameter" | "removeBrandFunction", [], unknown, TSESLint.RuleListener> & {
+    name: string;
+};

package/dist/rules/require-brand-type-parameter.js

@@ -0,0 +1,57 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { getRuleURL } from "../meta.js";
+import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
+export const requireBrandTypeParameter = ESLintUtils.RuleCreator(getRuleURL)({
+    name: 'require-brand-type-parameter',
+    meta: {
+        hasSuggestions: true,
+        type: 'problem',
+        docs: {
+            description: 'Require type parameter on `.brand()` functions',
+        },
+        messages: {
+            missingTypeParameter: 'Type parameter is required when using `.brand()`',
+            removeBrandFunction: 'Brand is a static-only construct. If not parameter is required consider removal',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
+        return {
+            ImportDeclaration: importDeclarationListener,
+            CallExpression(node) {
+                const zodSchemaMeta = detectZodSchemaRootNode(node);
+                if (!zodSchemaMeta) {
+                    return;
+                }
+                const methods = collectZodChainMethods(zodSchemaMeta.node);
+                const brandMethod = methods.find((it) => it.name === 'brand');
+                if (!brandMethod) {
+                    return;
+                }
+                const brandNode = brandMethod.node;
+                const { typeArguments } = brandNode;
+                if (typeArguments && typeArguments.params.length > 0) {
+                    return;
+                }
+                const brandCalleeNode = brandNode.callee;
+                context.report({
+                    messageId: 'missingTypeParameter',
+                    node: brandCalleeNode.property,
+                    suggest: [
+                        {
+                            messageId: 'removeBrandFunction',
+                            fix(fixer) {
+                                return fixer.removeRange([
+                                    brandCalleeNode.object.range[1],
+                                    brandNode.range[1],
+                                ]);
+                            },
+                        },
+                    ],
+                });
+            },
+        };
+    },
+});

package/dist/rules/require-error-message.cjs

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireErrorMessage = 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.requireErrorMessage = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+    name: 'require-error-message',
+    meta: {
+        type: 'suggestion',
+        fixable: 'code',
+        docs: {
+            description: 'Enforce that custom refinements include an error message',
+        },
+        messages: {
+            requireErrorMessage: 'Custom refinements must include an error message',
+            preferError: 'Use the "error" property instead of the deprecated "message" property',
+            removeMessage: 'The "message" property is deprecated; use "error"',
+        },
+        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) {
+                    return;
+                }
+                const refine = collectZodChainMethods(node).find((it) => it.name === 'refine' || it.name === 'custom');
+                if (!refine) {
+                    return;
+                }
+                const refineNode = refine.node;
+                if (refineNode.arguments.length < 2) {
+                    context.report({
+                        messageId: 'requireErrorMessage',
+                        node: node.callee,
+                    });
+                    return;
+                }
+                const [, params] = refineNode.arguments;
+                if (params.type === utils_1.AST_NODE_TYPES.Literal) {
+                    return;
+                }
+                if (params.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                    let errorPropertyNode;
+                    let messagePropertyNode;
+                    for (const property of params.properties) {
+                        if (property.type === utils_1.AST_NODE_TYPES.Property &&
+                            property.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            if (property.key.name === 'error') {
+                                errorPropertyNode = property;
+                            }
+                            if (property.key.name === 'message') {
+                                messagePropertyNode = property;
+                            }
+                            if (errorPropertyNode && messagePropertyNode) {
+                                break;
+                            }
+                        }
+                    }
+                    if (errorPropertyNode && messagePropertyNode) {
+                        context.report({
+                            messageId: 'removeMessage',
+                            node: messagePropertyNode,
+                            fix(fixer) {
+                                const { sourceCode } = context;
+                                const nextToken = sourceCode.getTokenAfter(messagePropertyNode);
+                                let [, end] = messagePropertyNode.range;
+                                if ((nextToken === null || nextToken === void 0 ? void 0 : nextToken.value) === ',') {
+                                    end = nextToken.range[1];
+                                }
+                                return fixer.removeRange([messagePropertyNode.range[0], end]);
+                            },
+                        });
+                        return;
+                    }
+                    if (messagePropertyNode && !errorPropertyNode) {
+                        context.report({
+                            messageId: 'preferError',
+                            node: params,
+                            fix(fixer) {
+                                return fixer.replaceTextRange(messagePropertyNode.key.range, 'error');
+                            },
+                        });
+                        return;
+                    }
+                    if (!errorPropertyNode) {
+                        context.report({
+                            messageId: 'requireErrorMessage',
+                            node: params,
+                        });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/require-error-message.d.cts

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

package/dist/rules/require-error-message.d.ts

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

package/dist/rules/require-error-message.js

@@ -0,0 +1,98 @@
+import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
+import { getRuleURL } from "../meta.js";
+import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
+export const requireErrorMessage = ESLintUtils.RuleCreator(getRuleURL)({
+    name: 'require-error-message',
+    meta: {
+        type: 'suggestion',
+        fixable: 'code',
+        docs: {
+            description: 'Enforce that custom refinements include an error message',
+        },
+        messages: {
+            requireErrorMessage: 'Custom refinements must include an error message',
+            preferError: 'Use the "error" property instead of the deprecated "message" property',
+            removeMessage: 'The "message" property is deprecated; use "error"',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
+        return {
+            ImportDeclaration: importDeclarationListener,
+            CallExpression(node) {
+                const zodSchemaMeta = detectZodSchemaRootNode(node);
+                if (!zodSchemaMeta) {
+                    return;
+                }
+                const refine = collectZodChainMethods(node).find((it) => it.name === 'refine' || it.name === 'custom');
+                if (!refine) {
+                    return;
+                }
+                const refineNode = refine.node;
+                if (refineNode.arguments.length < 2) {
+                    context.report({
+                        messageId: 'requireErrorMessage',
+                        node: node.callee,
+                    });
+                    return;
+                }
+                const [, params] = refineNode.arguments;
+                if (params.type === AST_NODE_TYPES.Literal) {
+                    return;
+                }
+                if (params.type === AST_NODE_TYPES.ObjectExpression) {
+                    let errorPropertyNode;
+                    let messagePropertyNode;
+                    for (const property of params.properties) {
+                        if (property.type === AST_NODE_TYPES.Property &&
+                            property.key.type === AST_NODE_TYPES.Identifier) {
+                            if (property.key.name === 'error') {
+                                errorPropertyNode = property;
+                            }
+                            if (property.key.name === 'message') {
+                                messagePropertyNode = property;
+                            }
+                            if (errorPropertyNode && messagePropertyNode) {
+                                break;
+                            }
+                        }
+                    }
+                    if (errorPropertyNode && messagePropertyNode) {
+                        context.report({
+                            messageId: 'removeMessage',
+                            node: messagePropertyNode,
+                            fix(fixer) {
+                                const { sourceCode } = context;
+                                const nextToken = sourceCode.getTokenAfter(messagePropertyNode);
+                                let [, end] = messagePropertyNode.range;
+                                if ((nextToken === null || nextToken === void 0 ? void 0 : nextToken.value) === ',') {
+                                    end = nextToken.range[1];
+                                }
+                                return fixer.removeRange([messagePropertyNode.range[0], end]);
+                            },
+                        });
+                        return;
+                    }
+                    if (messagePropertyNode && !errorPropertyNode) {
+                        context.report({
+                            messageId: 'preferError',
+                            node: params,
+                            fix(fixer) {
+                                return fixer.replaceTextRange(messagePropertyNode.key.range, 'error');
+                            },
+                        });
+                        return;
+                    }
+                    if (!errorPropertyNode) {
+                        context.report({
+                            messageId: 'requireErrorMessage',
+                            node: params,
+                        });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/require-schema-suffix.cjs

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireSchemaSuffix = 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.requireSchemaSuffix = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+    name: 'require-schema-suffix',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Require schema suffix when declaring a Zod schema',
+        },
+        messages: {
+            noSchemaSuffix: 'Use the "{{suffix}}" suffix for Zod schemas. Rename this to "{{expected}}"',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    suffix: {
+                        type: 'string',
+                        description: 'The required suffix for Zod schema variables',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{ suffix: 'Schema' }],
+    create(context, [{ suffix }]) {
+        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = (0, track_zod_schema_imports_js_1.trackZodSchemaImports)();
+        return {
+            ImportDeclaration: importDeclarationListener,
+            VariableDeclarator(node) {
+                const initNode = node.init;
+                if ((initNode === null || initNode === void 0 ? void 0 : initNode.type) !== utils_1.AST_NODE_TYPES.CallExpression ||
+                    !detectZodSchemaRootNode(initNode)) {
+                    return;
+                }
+                const chainMethods = collectZodChainMethods(initNode).map((it) => it.name);
+                const methodsThatProduceSomethingThatShouldNotBeValidated = [
+                    'parse',
+                    'parseAsync',
+                    'safeParse',
+                    'safeParseAsync',
+                    'spa',
+                    'encode',
+                    'encodeAsync',
+                    'decode',
+                    'decodeAsync',
+                    'safeEncode',
+                    'safeEncodeAsync',
+                    'safeDecode',
+                    'safeDecodeAsync',
+                    'codec',
+                ];
+                if (methodsThatProduceSomethingThatShouldNotBeValidated.some((it) => chainMethods.includes(it))) {
+                    return;
+                }
+                if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                    node.id.name.endsWith(suffix)) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'noSchemaSuffix',
+                    data: { suffix, expected: `${node.id.name}${suffix}` },
+                });
+            },
+        };
+    },
+});

package/dist/rules/require-schema-suffix.d.cts

@@ -0,0 +1,8 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+interface Options {
+    suffix: string;
+}
+export declare const requireSchemaSuffix: ESLintUtils.RuleModule<"noSchemaSuffix", [Options], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export {};

package/dist/rules/require-schema-suffix.d.ts

@@ -0,0 +1,8 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+interface Options {
+    suffix: string;
+}
+export declare const requireSchemaSuffix: ESLintUtils.RuleModule<"noSchemaSuffix", [Options], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export {};

package/dist/rules/require-schema-suffix.js

@@ -0,0 +1,70 @@
+import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
+import { getRuleURL } from "../meta.js";
+import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
+export const requireSchemaSuffix = ESLintUtils.RuleCreator(getRuleURL)({
+    name: 'require-schema-suffix',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Require schema suffix when declaring a Zod schema',
+        },
+        messages: {
+            noSchemaSuffix: 'Use the "{{suffix}}" suffix for Zod schemas. Rename this to "{{expected}}"',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    suffix: {
+                        type: 'string',
+                        description: 'The required suffix for Zod schema variables',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{ suffix: 'Schema' }],
+    create(context, [{ suffix }]) {
+        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
+        return {
+            ImportDeclaration: importDeclarationListener,
+            VariableDeclarator(node) {
+                const initNode = node.init;
+                if ((initNode === null || initNode === void 0 ? void 0 : initNode.type) !== AST_NODE_TYPES.CallExpression ||
+                    !detectZodSchemaRootNode(initNode)) {
+                    return;
+                }
+                const chainMethods = collectZodChainMethods(initNode).map((it) => it.name);
+                const methodsThatProduceSomethingThatShouldNotBeValidated = [
+                    'parse',
+                    'parseAsync',
+                    'safeParse',
+                    'safeParseAsync',
+                    'spa',
+                    'encode',
+                    'encodeAsync',
+                    'decode',
+                    'decodeAsync',
+                    'safeEncode',
+                    'safeEncodeAsync',
+                    'safeDecode',
+                    'safeDecodeAsync',
+                    'codec',
+                ];
+                if (methodsThatProduceSomethingThatShouldNotBeValidated.some((it) => chainMethods.includes(it))) {
+                    return;
+                }
+                if (node.id.type !== AST_NODE_TYPES.Identifier ||
+                    node.id.name.endsWith(suffix)) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'noSchemaSuffix',
+                    data: { suffix, expected: `${node.id.name}${suffix}` },
+                });
+            },
+        };
+    },
+});

package/dist/rules/schema-error-property-style.cjs

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaErrorPropertyStyle = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const esquery_1 = __importDefault(require("esquery"));
+const meta_js_1 = require("../meta.cjs");
+const track_zod_schema_imports_js_1 = require("../utils/track-zod-schema-imports.cjs");
+exports.schemaErrorPropertyStyle = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+    name: 'schema-error-property-style',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce consistent style for error messages in Zod schema validation (using ESQuery patterns)',
+        },
+        messages: {
+            invalidSelector: 'Invalid ESQuery selector: "{{selector}}"',
+            invalidStyle: 'Error message must follow the pattern "{{selector}}" (e.g., {{example}}). Found: {{actual}}.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    selector: {
+                        description: 'An ESQuery string to match the required pattern',
+                        type: 'string',
+                    },
+                    example: {
+                        description: 'Example code to help the user understand the required pattern',
+                        type: 'string',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [
+        { selector: 'Literal,TemplateLiteral', example: "'error message'" },
+    ],
+    create(context, [{ selector, example }]) {
+        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = (0, track_zod_schema_imports_js_1.trackZodSchemaImports)();
+        try {
+            esquery_1.default.parse(selector);
+        }
+        catch (_a) {
+            context.report({
+                loc: { line: 1, column: 0 },
+                messageId: 'invalidSelector',
+                data: { selector },
+            });
+            return {};
+        }
+        return {
+            ImportDeclaration: importDeclarationListener,
+            CallExpression(node) {
+                const zodSchemaMeta = detectZodSchemaRootNode(node);
+                if (!zodSchemaMeta) {
+                    return;
+                }
+                if (zodSchemaMeta.schemaType !== 'custom' &&
+                    !collectZodChainMethods(node).some((it) => it.name === 'refine')) {
+                    return;
+                }
+                if (node.arguments.length < 2) {
+                    return;
+                }
+                let errorMessageNode;
+                const [, params] = node.arguments;
+                switch (params.type) {
+                    case utils_1.AST_NODE_TYPES.Literal:
+                    case utils_1.AST_NODE_TYPES.TemplateLiteral:
+                        errorMessageNode = params;
+                        break;
+                    case utils_1.AST_NODE_TYPES.ObjectExpression:
+                        for (const property of params.properties) {
+                            if (property.type === utils_1.AST_NODE_TYPES.Property &&
+                                property.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                property.key.name === 'error') {
+                                errorMessageNode = property.value;
+                                break;
+                            }
+                        }
+                        break;
+                }
+                if (!errorMessageNode) {
+                    return;
+                }
+                const match = esquery_1.default.matches(errorMessageNode, esquery_1.default.parse(selector), errorMessageNode);
+                if (match) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'invalidStyle',
+                    data: {
+                        selector,
+                        example,
+                        actual: context.sourceCode.getText(errorMessageNode),
+                    },
+                });
+            },
+        };
+    },
+});

package/dist/rules/schema-error-property-style.d.cts

@@ -0,0 +1,9 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+type MessageIds = 'invalidStyle' | 'invalidSelector';
+export declare const schemaErrorPropertyStyle: ESLintUtils.RuleModule<MessageIds, [{
+    selector: string;
+    example: string;
+}], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export {};

package/dist/rules/schema-error-property-style.d.ts

@@ -0,0 +1,9 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+type MessageIds = 'invalidStyle' | 'invalidSelector';
+export declare const schemaErrorPropertyStyle: ESLintUtils.RuleModule<MessageIds, [{
+    selector: string;
+    example: string;
+}], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export {};