eslint-plugin-zod 1.3.0 → 3.0.0

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

@@ -0,0 +1,100 @@
+import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
+import esquery from 'esquery';
+import { getRuleURL } from "../meta.js";
+import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
+export const schemaErrorPropertyStyle = ESLintUtils.RuleCreator(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, } = trackZodSchemaImports();
+        try {
+            esquery.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 AST_NODE_TYPES.Literal:
+                    case AST_NODE_TYPES.TemplateLiteral:
+                        errorMessageNode = params;
+                        break;
+                    case AST_NODE_TYPES.ObjectExpression:
+                        for (const property of params.properties) {
+                            if (property.type === AST_NODE_TYPES.Property &&
+                                property.key.type === AST_NODE_TYPES.Identifier &&
+                                property.key.name === 'error') {
+                                errorMessageNode = property.value;
+                                break;
+                            }
+                        }
+                        break;
+                }
+                if (!errorMessageNode) {
+                    return;
+                }
+                const match = esquery.matches(errorMessageNode, esquery.parse(selector), errorMessageNode);
+                if (match) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'invalidStyle',
+                    data: {
+                        selector,
+                        example,
+                        actual: context.sourceCode.getText(errorMessageNode),
+                    },
+                });
+            },
+        };
+    },
+});

package/dist/utils/detect-zod-schema-root-node.cjs

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectZodSchemaRootNode = detectZodSchemaRootNode;
+const utils_1 = require("@typescript-eslint/utils");
+function getPropertyName(prop) {
+    if (!prop) {
+        return null;
+    }
+    if (prop.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return prop.name;
+    }
+    if (prop.type === utils_1.AST_NODE_TYPES.Literal) {
+        return prop.value == null ? null : String(prop.value);
+    }
+    if (prop.type === utils_1.AST_NODE_TYPES.TemplateLiteral) {
+        if (prop.expressions.length === 0 && prop.quasis.length === 1) {
+            return prop.quasis[0].value.cooked;
+        }
+        return null;
+    }
+    return null;
+}
+function isOutermostCallExpression(node) {
+    const { parent } = node;
+    if (parent.type === utils_1.AST_NODE_TYPES.CallExpression && parent.callee === node) {
+        return false;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        parent.object === node) {
+        return false;
+    }
+    return true;
+}
+function parseZodCallExpression(call, zodNamespaces, zodNamedImports) {
+    var _a;
+    let cur = call.callee;
+    const methodsRightToLeft = [];
+    let leftmostIdentifier = null;
+    while (true) {
+        if (cur.type === utils_1.AST_NODE_TYPES.CallExpression) {
+            cur = cur.callee;
+            continue;
+        }
+        if (cur.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+            const name = getPropertyName(cur.property);
+            if (!name) {
+                return null;
+            }
+            methodsRightToLeft.push(name);
+            cur = cur.object;
+            continue;
+        }
+        if (cur.type === utils_1.AST_NODE_TYPES.Identifier) {
+            leftmostIdentifier = cur.name;
+            break;
+        }
+        return null;
+    }
+    const methods = methodsRightToLeft.slice().reverse();
+    if (!leftmostIdentifier) {
+        return null;
+    }
+    if (zodNamespaces.has(leftmostIdentifier)) {
+        const factory = (_a = methods[0]) !== null && _a !== void 0 ? _a : null;
+        if (!factory) {
+            return null;
+        }
+        return {
+            schemaDecl: 'namespace',
+            schemaType: factory,
+            methods,
+            node: call,
+        };
+    }
+    if (zodNamedImports.has(leftmostIdentifier)) {
+        const factory = leftmostIdentifier;
+        return {
+            schemaDecl: 'named',
+            schemaType: factory,
+            methods,
+            node: call,
+        };
+    }
+    return null;
+}
+function detectZodSchemaRootNode(node, zodNamespaces, zodNamedImports) {
+    if (node.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+        return null;
+    }
+    const call = node;
+    if (!isOutermostCallExpression(call)) {
+        return null;
+    }
+    const outer = parseZodCallExpression(call, zodNamespaces, zodNamedImports);
+    if (!outer) {
+        return null;
+    }
+    return {
+        schemaDecl: outer.schemaDecl,
+        schemaType: outer.schemaType,
+        methods: outer.methods,
+        node: call,
+    };
+}

package/dist/utils/detect-zod-schema-root-node.d.cts

@@ -0,0 +1,10 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+interface DetectData {
+    schemaDecl: 'namespace' | 'named';
+    schemaType: string;
+    methods: Array<string>;
+    node: TSESTree.CallExpression;
+}
+export type DetectResult = (DetectData & {}) | null;
+export declare function detectZodSchemaRootNode(node: TSESTree.Node, zodNamespaces: Set<string>, zodNamedImports: Set<string>): DetectResult;
+export {};

package/dist/utils/detect-zod-schema-root-node.d.ts

@@ -0,0 +1,10 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+interface DetectData {
+    schemaDecl: 'namespace' | 'named';
+    schemaType: string;
+    methods: Array<string>;
+    node: TSESTree.CallExpression;
+}
+export type DetectResult = (DetectData & {}) | null;
+export declare function detectZodSchemaRootNode(node: TSESTree.Node, zodNamespaces: Set<string>, zodNamedImports: Set<string>): DetectResult;
+export {};

package/dist/utils/detect-zod-schema-root-node.js

@@ -0,0 +1,101 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+function getPropertyName(prop) {
+    if (!prop) {
+        return null;
+    }
+    if (prop.type === AST_NODE_TYPES.Identifier) {
+        return prop.name;
+    }
+    if (prop.type === AST_NODE_TYPES.Literal) {
+        return prop.value == null ? null : String(prop.value);
+    }
+    if (prop.type === AST_NODE_TYPES.TemplateLiteral) {
+        if (prop.expressions.length === 0 && prop.quasis.length === 1) {
+            return prop.quasis[0].value.cooked;
+        }
+        return null;
+    }
+    return null;
+}
+function isOutermostCallExpression(node) {
+    const { parent } = node;
+    if (parent.type === AST_NODE_TYPES.CallExpression && parent.callee === node) {
+        return false;
+    }
+    if (parent.type === AST_NODE_TYPES.MemberExpression &&
+        parent.object === node) {
+        return false;
+    }
+    return true;
+}
+function parseZodCallExpression(call, zodNamespaces, zodNamedImports) {
+    var _a;
+    let cur = call.callee;
+    const methodsRightToLeft = [];
+    let leftmostIdentifier = null;
+    while (true) {
+        if (cur.type === AST_NODE_TYPES.CallExpression) {
+            cur = cur.callee;
+            continue;
+        }
+        if (cur.type === AST_NODE_TYPES.MemberExpression) {
+            const name = getPropertyName(cur.property);
+            if (!name) {
+                return null;
+            }
+            methodsRightToLeft.push(name);
+            cur = cur.object;
+            continue;
+        }
+        if (cur.type === AST_NODE_TYPES.Identifier) {
+            leftmostIdentifier = cur.name;
+            break;
+        }
+        return null;
+    }
+    const methods = methodsRightToLeft.slice().reverse();
+    if (!leftmostIdentifier) {
+        return null;
+    }
+    if (zodNamespaces.has(leftmostIdentifier)) {
+        const factory = (_a = methods[0]) !== null && _a !== void 0 ? _a : null;
+        if (!factory) {
+            return null;
+        }
+        return {
+            schemaDecl: 'namespace',
+            schemaType: factory,
+            methods,
+            node: call,
+        };
+    }
+    if (zodNamedImports.has(leftmostIdentifier)) {
+        const factory = leftmostIdentifier;
+        return {
+            schemaDecl: 'named',
+            schemaType: factory,
+            methods,
+            node: call,
+        };
+    }
+    return null;
+}
+export function detectZodSchemaRootNode(node, zodNamespaces, zodNamedImports) {
+    if (node.type !== AST_NODE_TYPES.CallExpression) {
+        return null;
+    }
+    const call = node;
+    if (!isOutermostCallExpression(call)) {
+        return null;
+    }
+    const outer = parseZodCallExpression(call, zodNamespaces, zodNamedImports);
+    if (!outer) {
+        return null;
+    }
+    return {
+        schemaDecl: outer.schemaDecl,
+        schemaType: outer.schemaType,
+        methods: outer.methods,
+        node: call,
+    };
+}

package/dist/utils/get-outermost-call.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOutermostCall = getOutermostCall;
+const utils_1 = require("@typescript-eslint/utils");
+function getOutermostCall(node) {
+    var _a;
+    let current = node;
+    while (((_a = current.parent) === null || _a === void 0 ? void 0 : _a.type) === utils_1.AST_NODE_TYPES.MemberExpression &&
+        current.parent.object === current &&
+        current.parent.parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
+        current = current.parent.parent;
+    }
+    return current.type === utils_1.AST_NODE_TYPES.CallExpression ? current : null;
+}

package/dist/utils/get-outermost-call.d.cts

@@ -0,0 +1,2 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+export declare function getOutermostCall(node: TSESTree.Node): TSESTree.CallExpression | null;

package/dist/utils/get-outermost-call.d.ts

@@ -0,0 +1,2 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+export declare function getOutermostCall(node: TSESTree.Node): TSESTree.CallExpression | null;

package/dist/utils/get-outermost-call.js

@@ -0,0 +1,11 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+export function getOutermostCall(node) {
+    var _a;
+    let current = node;
+    while (((_a = current.parent) === null || _a === void 0 ? void 0 : _a.type) === AST_NODE_TYPES.MemberExpression &&
+        current.parent.object === current &&
+        current.parent.parent.type === AST_NODE_TYPES.CallExpression) {
+        current = current.parent.parent;
+    }
+    return current.type === AST_NODE_TYPES.CallExpression ? current : null;
+}

package/dist/utils/is-zod-expression.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isZodExpressionEndingWithMethod = isZodExpressionEndingWithMethod;
+const utils_1 = require("@typescript-eslint/utils");
+function isZodExpressionEndingWithMethod(node, propName) {
+    if (node.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+        return false;
+    }
+    if (node.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+        node.property.name === propName) {
+        return true;
+    }
+    return false;
+}

package/dist/utils/is-zod-expression.d.cts

@@ -0,0 +1,2 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+export declare function isZodExpressionEndingWithMethod(node: TSESTree.Node, propName: string): node is TSESTree.MemberExpression;

package/dist/utils/is-zod-expression.d.ts

@@ -0,0 +1,2 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+export declare function isZodExpressionEndingWithMethod(node: TSESTree.Node, propName: string): node is TSESTree.MemberExpression;

package/dist/utils/is-zod-expression.js

@@ -0,0 +1,11 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+export function isZodExpressionEndingWithMethod(node, propName) {
+    if (node.type !== AST_NODE_TYPES.MemberExpression) {
+        return false;
+    }
+    if (node.property.type === AST_NODE_TYPES.Identifier &&
+        node.property.name === propName) {
+        return true;
+    }
+    return false;
+}

package/dist/utils/is-zod-import-source.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isZodImportSource = isZodImportSource;
+function isZodImportSource(source) {
+    return source === 'zod' || source.startsWith('zod/');
+}

package/dist/utils/is-zod-import-source.d.cts

@@ -0,0 +1 @@
+export declare function isZodImportSource(source: string): boolean;

package/dist/utils/is-zod-import-source.d.ts

@@ -0,0 +1 @@
+export declare function isZodImportSource(source: string): boolean;

package/dist/utils/is-zod-import-source.js

@@ -0,0 +1,3 @@
+export function isZodImportSource(source) {
+    return source === 'zod' || source.startsWith('zod/');
+}

package/dist/utils/track-zod-schema-imports.cjs

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackZodSchemaImports = trackZodSchemaImports;
+const utils_1 = require("@typescript-eslint/utils");
+const detect_zod_schema_root_node_js_1 = require("./detect-zod-schema-root-node.cjs");
+const is_zod_import_source_js_1 = require("./is-zod-import-source.cjs");
+function trackZodSchemaImports() {
+    const zodNamespaces = new Set();
+    const zodNamedImports = new Set();
+    function collectZodChainMethods(node) {
+        const methods = [];
+        let current = node;
+        while (current.type === utils_1.AST_NODE_TYPES.CallExpression) {
+            const { callee } = current;
+            if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                methods.unshift({
+                    name: callee.property.name,
+                    node: current,
+                });
+                current = callee.object;
+                continue;
+            }
+            if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                methods.unshift({
+                    name: callee.name,
+                    node: current,
+                });
+                break;
+            }
+            break;
+        }
+        return methods;
+    }
+    const result = {
+        importDeclarationListener(node) {
+            if (!(0, is_zod_import_source_js_1.isZodImportSource)(node.source.value)) {
+                return;
+            }
+            for (const spec of node.specifiers) {
+                switch (spec.type) {
+                    case utils_1.AST_NODE_TYPES.ImportDefaultSpecifier:
+                    case utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier:
+                        zodNamespaces.add(spec.local.name);
+                        break;
+                    case utils_1.AST_NODE_TYPES.ImportSpecifier:
+                        if ('name' in spec.imported && spec.imported.name === 'z') {
+                            zodNamespaces.add(spec.local.name);
+                        }
+                        else {
+                            zodNamedImports.add(spec.local.name);
+                        }
+                        break;
+                }
+            }
+        },
+        detectZodSchemaRootNode: (node) => (0, detect_zod_schema_root_node_js_1.detectZodSchemaRootNode)(node, zodNamespaces, zodNamedImports),
+        collectZodChainMethods,
+    };
+    return result;
+}

package/dist/utils/track-zod-schema-imports.d.cts

@@ -0,0 +1,13 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+import type { DetectResult } from "./detect-zod-schema-root-node.cjs";
+interface ZodChainItem {
+    name: string;
+    node: TSESTree.CallExpression;
+}
+interface Result {
+    importDeclarationListener: (node: TSESTree.ImportDeclaration) => void;
+    detectZodSchemaRootNode: (node: TSESTree.Node) => null | DetectResult;
+    collectZodChainMethods: (node: TSESTree.CallExpression) => Array<ZodChainItem>;
+}
+export declare function trackZodSchemaImports(): Result;
+export {};

package/dist/utils/track-zod-schema-imports.d.ts

@@ -0,0 +1,13 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+import type { DetectResult } from "./detect-zod-schema-root-node.js";
+interface ZodChainItem {
+    name: string;
+    node: TSESTree.CallExpression;
+}
+interface Result {
+    importDeclarationListener: (node: TSESTree.ImportDeclaration) => void;
+    detectZodSchemaRootNode: (node: TSESTree.Node) => null | DetectResult;
+    collectZodChainMethods: (node: TSESTree.CallExpression) => Array<ZodChainItem>;
+}
+export declare function trackZodSchemaImports(): Result;
+export {};

package/dist/utils/track-zod-schema-imports.js

@@ -0,0 +1,58 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { detectZodSchemaRootNode } from "./detect-zod-schema-root-node.js";
+import { isZodImportSource } from "./is-zod-import-source.js";
+export function trackZodSchemaImports() {
+    const zodNamespaces = new Set();
+    const zodNamedImports = new Set();
+    function collectZodChainMethods(node) {
+        const methods = [];
+        let current = node;
+        while (current.type === AST_NODE_TYPES.CallExpression) {
+            const { callee } = current;
+            if (callee.type === AST_NODE_TYPES.MemberExpression &&
+                callee.property.type === AST_NODE_TYPES.Identifier) {
+                methods.unshift({
+                    name: callee.property.name,
+                    node: current,
+                });
+                current = callee.object;
+                continue;
+            }
+            if (callee.type === AST_NODE_TYPES.Identifier) {
+                methods.unshift({
+                    name: callee.name,
+                    node: current,
+                });
+                break;
+            }
+            break;
+        }
+        return methods;
+    }
+    const result = {
+        importDeclarationListener(node) {
+            if (!isZodImportSource(node.source.value)) {
+                return;
+            }
+            for (const spec of node.specifiers) {
+                switch (spec.type) {
+                    case AST_NODE_TYPES.ImportDefaultSpecifier:
+                    case AST_NODE_TYPES.ImportNamespaceSpecifier:
+                        zodNamespaces.add(spec.local.name);
+                        break;
+                    case AST_NODE_TYPES.ImportSpecifier:
+                        if ('name' in spec.imported && spec.imported.name === 'z') {
+                            zodNamespaces.add(spec.local.name);
+                        }
+                        else {
+                            zodNamedImports.add(spec.local.name);
+                        }
+                        break;
+                }
+            }
+        },
+        detectZodSchemaRootNode: (node) => detectZodSchemaRootNode(node, zodNamespaces, zodNamedImports),
+        collectZodChainMethods,
+    };
+    return result;
+}