eslint-plugin-zod-mini 0.1.0

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

@@ -0,0 +1,161 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { requireErrorMessage } from './require-error-message.js';
+const ruleTester = new RuleTester();
+ruleTester.run(requireErrorMessage.name, requireErrorMessage, {
+    valid: [
+        {
+            name: 'object with error property (namespace import)',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.string().check(z.refine(() => true, { error: "error msg" }));
+      `,
+        },
+        {
+            name: 'object with error property (named import)',
+            code: dedent `
+        import { string, refine } from 'zod/mini';
+        string().check(refine(() => true, { error: "error msg" }));
+      `,
+        },
+        {
+            name: 'object with error property (named z import)',
+            code: dedent `
+        import { z } from 'zod/mini';
+        z.string().check(z.refine(() => true, { error: "error msg" }));
+      `,
+        },
+        {
+            name: 'string error message',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.string().check(z.refine(() => true, "error msg"));
+      `,
+        },
+        {
+            name: 'multiple chained checks with error',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.string()
+          .check(z.refine(() => true, { error: "error msg 1" }))
+          .check(z.refine(() => true, { error: "error msg 2" }));
+      `,
+        },
+        {
+            name: 'not triggered on zod import',
+            code: dedent `
+        import * as z from 'zod';
+        z.string().refine(() => true);
+      `,
+        },
+    ],
+    invalid: [
+        {
+            name: 'missing error message parameter',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.string().check(z.refine(() => true));
+      `,
+            errors: [{ messageId: 'requireErrorMessage' }],
+            output: null,
+        },
+        {
+            name: 'missing error message (named import)',
+            code: dedent `
+        import { string, refine } from 'zod/mini';
+        string().check(refine(() => true));
+      `,
+            errors: [{ messageId: 'requireErrorMessage' }],
+            output: null,
+        },
+        {
+            name: 'object without error message',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.string().check(z.refine(() => true, { abort: true }));
+      `,
+            errors: [{ messageId: 'requireErrorMessage' }],
+            output: null,
+        },
+        {
+            name: 'deprecated message property',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.string().check(z.refine(() => true, { message: "hello" }));
+      `,
+            errors: [{ messageId: 'preferError' }],
+            output: dedent `
+        import * as z from 'zod/mini';
+        z.string().check(z.refine(() => true, { error: "hello" }));
+      `,
+        },
+        {
+            name: 'both message and error — remove message',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.string().check(z.refine(() => true, { message: "hello", error: "hello" }));
+      `,
+            errors: [{ messageId: 'removeMessage' }],
+            output: dedent `
+        import * as z from 'zod/mini';
+        z.string().check(z.refine(() => true, {  error: "hello" }));
+      `,
+        },
+        {
+            name: 'zod/v4-mini import',
+            code: dedent `
+        import * as z from 'zod/v4-mini';
+        z.string().check(z.refine(() => true));
+      `,
+            errors: [{ messageId: 'requireErrorMessage' }],
+            output: null,
+        },
+    ],
+});
+ruleTester.run(`${requireErrorMessage.name} (custom)`, requireErrorMessage, {
+    valid: [
+        {
+            name: 'object with error property',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.custom(() => true, { error: "hello there" });
+      `,
+        },
+        {
+            name: 'string error message',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.custom(() => true, "error msg");
+      `,
+        },
+    ],
+    invalid: [
+        {
+            name: 'missing error message parameter',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.custom(() => true)
+      `,
+            errors: [{ messageId: 'requireErrorMessage' }],
+            output: null,
+        },
+        {
+            name: 'missing error message parameter (named)',
+            code: dedent `
+        import { custom } from 'zod/mini';
+        custom(() => true)
+      `,
+            errors: [{ messageId: 'requireErrorMessage' }],
+            output: null,
+        },
+        {
+            name: 'object without error message',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.custom(() => true, { abort: true });
+      `,
+            errors: [{ messageId: 'requireErrorMessage' }],
+            output: null,
+        },
+    ],
+});

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

@@ -0,0 +1,9 @@
+interface Options {
+    suffix: string;
+}
+export declare const requireSchemaSuffix: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noSchemaSuffix", [Options], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export {};

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

@@ -0,0 +1,79 @@
+import { createZodSchemaImportTrack } from '@eslint-zod/utils';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { createZodMiniPluginRule } from '../utils/create-plugin-rule.js';
+const { zodImportAllowedSource, trackZodSchemaImports, } = createZodSchemaImportTrack('zod-mini');
+export const requireSchemaSuffix = createZodMiniPluginRule({
+    name: 'require-schema-suffix',
+    meta: {
+        type: 'suggestion',
+        deprecated: {
+            message: 'Use `zod-mini/consistent-schema-var-name`',
+        },
+        docs: {
+            zodImportAllowedSource,
+            description: 'Require schema suffix when declaring a Zod Mini schema',
+        },
+        messages: {
+            noSchemaSuffix: 'Use the "{{suffix}}" suffix for Zod Mini schemas. Rename this to "{{expected}}"',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    suffix: {
+                        type: 'string',
+                        description: 'The required suffix for Zod Mini 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',
+                    'treeifyError',
+                    'prettifyError',
+                    'formatError',
+                    'flattenError',
+                ];
+                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/src/rules/require-schema-suffix.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,131 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { requireSchemaSuffix } from './require-schema-suffix.js';
+const ruleTester = new RuleTester();
+ruleTester.run(requireSchemaSuffix.name, requireSchemaSuffix, {
+    valid: [
+        {
+            name: 'valid (default suffix)',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const userSchema = z.string();
+      `,
+        },
+        {
+            name: 'valid with multiple declarations',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const userSchema = z.string(), addressSchema = z.object({ street: z.string() });
+      `,
+        },
+        {
+            name: 'with parse()',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const value = z.string().parse("asd")
+      `,
+        },
+        {
+            name: 'custom suffix',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const userVar = z.string()
+      `,
+            options: [{ suffix: 'Var' }],
+        },
+        {
+            name: 'not triggered on zod import',
+            code: dedent `
+        import * as z from 'zod';
+        const myVar = z.string();
+      `,
+        },
+        {
+            name: 'ignores non-zod/mini values',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const myVar = 1
+      `,
+        },
+        {
+            name: 'zod/v4-mini import',
+            code: dedent `
+        import * as z from 'zod/v4-mini';
+        const userSchema = z.string();
+      `,
+        },
+    ],
+    invalid: [
+        {
+            name: 'namespace (missing suffix)',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const myVar = z.string();
+      `,
+            errors: [
+                {
+                    messageId: 'noSchemaSuffix',
+                    data: { suffix: 'Schema', expected: 'myVarSchema' },
+                },
+            ],
+            output: null,
+        },
+        {
+            name: 'named import (missing suffix)',
+            code: dedent `
+        import { string } from 'zod/mini';
+        const myVar = string();
+      `,
+            errors: [
+                {
+                    messageId: 'noSchemaSuffix',
+                    data: { suffix: 'Schema', expected: 'myVarSchema' },
+                },
+            ],
+            output: null,
+        },
+        {
+            name: 'chained method (missing suffix)',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const myVar = z.string().check(z.min(1));
+      `,
+            errors: [
+                {
+                    messageId: 'noSchemaSuffix',
+                    data: { suffix: 'Schema', expected: 'myVarSchema' },
+                },
+            ],
+            output: null,
+        },
+        {
+            name: 'custom suffix (missing)',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const myString = z.string()
+      `,
+            options: [{ suffix: '_schema' }],
+            errors: [
+                {
+                    messageId: 'noSchemaSuffix',
+                    data: { suffix: '_schema', expected: 'myString_schema' },
+                },
+            ],
+            output: null,
+        },
+        {
+            name: 'zod/v4-mini import (missing suffix)',
+            code: dedent `
+        import * as z from 'zod/v4-mini';
+        const myVar = z.string();
+      `,
+            errors: [
+                {
+                    messageId: 'noSchemaSuffix',
+                    data: { suffix: 'Schema', expected: 'myVarSchema' },
+                },
+            ],
+            output: null,
+        },
+    ],
+});

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

@@ -0,0 +1,10 @@
+type MessageIds = 'invalidStyle' | 'invalidSelector';
+export declare const schemaErrorPropertyStyle: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, [{
+    selector: string;
+    example: string;
+}], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export {};

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

@@ -0,0 +1,102 @@
+import { createZodSchemaImportTrack } from '@eslint-zod/utils';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import esquery from 'esquery';
+import { createZodMiniPluginRule } from '../utils/create-plugin-rule.js';
+const { zodImportAllowedSource, trackZodSchemaImports, } = createZodSchemaImportTrack('zod-mini');
+export const schemaErrorPropertyStyle = createZodMiniPluginRule({
+    name: 'schema-error-property-style',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            zodImportAllowedSource,
+            description: 'Enforce consistent style for error messages in Zod Mini 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/src/rules/schema-error-property-style.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,134 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { schemaErrorPropertyStyle } from './schema-error-property-style.js';
+const ruleTester = new RuleTester();
+ruleTester.run(schemaErrorPropertyStyle.name, schemaErrorPropertyStyle, {
+    valid: [
+        {
+            name: 'default option (namespace import)',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.custom(() => true, { error: "my error" })
+      `,
+        },
+        {
+            name: 'default option (named import)',
+            code: dedent `
+        import { custom } from 'zod/mini';
+        custom(() => true, { error: "my error" })
+      `,
+        },
+        {
+            name: 'default option (named z import)',
+            code: dedent `
+        import { z } from 'zod/mini';
+        z.custom(() => true, { error: "my error" })
+      `,
+        },
+        {
+            name: 'not triggered on zod import',
+            code: dedent `
+        import { custom } from 'zod';
+        custom(() => true, { error: () => "my error" })
+      `,
+        },
+        {
+            name: 'template string',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.custom(() => true, \`asd\`);
+      `,
+        },
+    ],
+    invalid: [
+        {
+            name: 'arrow function error value',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.custom(() => true, { error: () => "my error" })
+      `,
+            errors: [
+                {
+                    messageId: 'invalidStyle',
+                    data: {
+                        selector: 'Literal,TemplateLiteral',
+                        example: "'error message'",
+                        actual: '() => "my error"',
+                    },
+                },
+            ],
+            output: null,
+        },
+        {
+            name: 'invalid ESQuery selector',
+            options: [{ selector: '>!asd', example: 'test' }],
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.custom(() => true, \`template string\`)
+      `,
+            errors: [
+                {
+                    messageId: 'invalidSelector',
+                    data: { selector: '>!asd' },
+                },
+            ],
+            output: null,
+        },
+        {
+            name: 'zod/v4-mini import',
+            code: dedent `
+        import * as z from 'zod/v4-mini';
+        z.custom(() => true, { error: () => "my error" })
+      `,
+            errors: [
+                {
+                    messageId: 'invalidStyle',
+                    data: {
+                        selector: 'Literal,TemplateLiteral',
+                        example: "'error message'",
+                        actual: '() => "my error"',
+                    },
+                },
+            ],
+            output: null,
+        },
+    ],
+});
+ruleTester.run(`${schemaErrorPropertyStyle.name} (refine)`, schemaErrorPropertyStyle, {
+    valid: [
+        {
+            name: 'default option',
+            code: dedent `
+          import * as z from 'zod/mini';
+          z.string().check(z.refine(() => true, { error: "my error" }));
+        `,
+        },
+        {
+            name: 'template string',
+            code: dedent `
+          import * as z from 'zod/mini';
+          z.string().check(z.refine(() => true, \`asd\`));
+        `,
+        },
+    ],
+    invalid: [
+        {
+            name: 'arrow function error value',
+            code: dedent `
+          import * as z from 'zod/mini';
+          z.string().check(z.refine(() => true, { error: () => "my error" }))
+        `,
+            errors: [
+                {
+                    messageId: 'invalidStyle',
+                    data: {
+                        selector: 'Literal,TemplateLiteral',
+                        example: "'error message'",
+                        actual: '() => "my error"',
+                    },
+                },
+            ],
+            output: null,
+        },
+    ],
+});

package/dist/src/utils/create-plugin-rule.d.ts

@@ -0,0 +1,8 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const createZodMiniPluginRule: <Options extends readonly unknown[], MessageIds extends string>({ meta, name, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<Options, MessageIds, {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}>>) => ESLintUtils.RuleModule<MessageIds, Options, {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/dist/src/utils/create-plugin-rule.js

@@ -0,0 +1,3 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { getRuleURL } from '../meta.js';
+export const createZodMiniPluginRule = ESLintUtils.RuleCreator(getRuleURL);

package/dist/tests/setup.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/setup.js

@@ -0,0 +1,12 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import { afterAll, describe, it } from 'vitest';
+RuleTester.describe = (...args) => {
+    describe(...args);
+};
+RuleTester.describeSkip = (...args) => {
+    describe.skip(...args);
+};
+RuleTester.it = it;
+RuleTester.itOnly = it.only;
+RuleTester.itSkip = it.skip;
+RuleTester.afterAll = afterAll;