eslint-plugin-zod-mini 0.1.0

package/dist/src/rules/consistent-object-schema-type.spec.js

@@ -0,0 +1,138 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { consistentObjectSchemaType } from './consistent-object-schema-type.js';
+const ruleTester = new RuleTester();
+ruleTester.run(consistentObjectSchemaType.name, consistentObjectSchemaType, {
+    valid: [
+        {
+            name: 'namespace import',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.object({})
+      `,
+        },
+        {
+            name: 'named import',
+            code: dedent `
+        import { object } from 'zod/mini';
+        object({})
+      `,
+        },
+        {
+            name: 'named z import',
+            code: dedent `
+        import { z } from 'zod/mini';
+        z.object({})
+      `,
+        },
+        {
+            name: 'nested with allowed methods',
+            options: [{ allow: ['looseObject', 'strictObject'] }],
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.looseObject({ test: z.strictObject({}) })
+      `,
+        },
+        {
+            name: 'not triggered on zod import',
+            code: dedent `
+        import * as z from 'zod';
+        z.looseObject({})
+      `,
+        },
+        {
+            name: 'zod/v4-mini import',
+            code: dedent `
+        import * as z from 'zod/v4-mini';
+        z.object({})
+      `,
+        },
+    ],
+    invalid: [
+        {
+            name: 'namespace import — looseObject not allowed by default',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.looseObject({})
+      `,
+            errors: [
+                {
+                    messageId: 'consistentMethod',
+                    data: { actual: 'looseObject', allowedList: 'object' },
+                    suggestions: [
+                        {
+                            messageId: 'useMethod',
+                            data: { expected: 'object' },
+                            output: dedent `
+                import * as z from 'zod/mini';
+                z.object({})
+              `,
+                        },
+                    ],
+                },
+            ],
+            output: null,
+        },
+        {
+            name: 'named import — no suggestion for Identifier callee',
+            code: dedent `
+        import { looseObject } from 'zod/mini';
+        looseObject()
+      `,
+            errors: [
+                {
+                    messageId: 'consistentMethod',
+                    data: { actual: 'looseObject', allowedList: 'object' },
+                },
+            ],
+            output: null,
+        },
+        {
+            name: 'nested looseObject',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.object({ test: z.looseObject({}) })
+      `,
+            errors: [
+                {
+                    messageId: 'consistentMethod',
+                    data: { actual: 'looseObject', allowedList: 'object' },
+                    suggestions: [
+                        {
+                            messageId: 'useMethod',
+                            data: { expected: 'object' },
+                            output: dedent `
+                import * as z from 'zod/mini';
+                z.object({ test: z.object({}) })
+              `,
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            name: 'zod/v4-mini import',
+            code: dedent `
+        import * as z from 'zod/v4-mini';
+        z.looseObject({})
+      `,
+            errors: [
+                {
+                    messageId: 'consistentMethod',
+                    data: { actual: 'looseObject', allowedList: 'object' },
+                    suggestions: [
+                        {
+                            messageId: 'useMethod',
+                            data: { expected: 'object' },
+                            output: dedent `
+                import * as z from 'zod/v4-mini';
+                z.object({})
+              `,
+                        },
+                    ],
+                },
+            ],
+            output: null,
+        },
+    ],
+});

package/dist/src/rules/consistent-schema-output-type-style.d.ts

@@ -0,0 +1,12 @@
+declare const ZOD_SCHEMA_TYPE_STYLES: readonly ["infer", "output"];
+type SchemaTypeStyle = (typeof ZOD_SCHEMA_TYPE_STYLES)[number];
+interface Options {
+    style: SchemaTypeStyle;
+}
+type MessageIds = 'useInfer' | 'useOutput';
+export declare const consistentSchemaOutputTypeStyle: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, [Options], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export {};

package/dist/src/rules/consistent-schema-output-type-style.js

@@ -0,0 +1,81 @@
+import { createZodSchemaImportTrack } from '@eslint-zod/utils';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { createZodMiniPluginRule } from '../utils/create-plugin-rule.js';
+const ZOD_SCHEMA_TYPE_STYLES = ['infer', 'output'];
+const { zodImportAllowedSource, trackZodSchemaImports, } = createZodSchemaImportTrack('zod-mini');
+export const consistentSchemaOutputTypeStyle = createZodMiniPluginRule({
+    name: 'consistent-schema-output-type-style',
+    meta: {
+        type: 'suggestion',
+        fixable: 'code',
+        docs: {
+            zodImportAllowedSource,
+            description: 'Enforce consistent use of z.infer or z.output for schema type inference',
+        },
+        messages: {
+            useInfer: 'Use infer instead of output.',
+            useOutput: 'Use output instead of infer.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    style: {
+                        description: 'Decides which style to use for schema type inference',
+                        type: 'string',
+                        enum: [...ZOD_SCHEMA_TYPE_STYLES],
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{ style: 'output' }],
+    create(context, [{ style }]) {
+        const { importDeclarationListener, isZodNamespace, getNamedImportOriginal, getNamedImportLocal, } = trackZodSchemaImports();
+        return {
+            ImportDeclaration: importDeclarationListener,
+            TSTypeReference(node) {
+                const { typeName } = node;
+                if (typeName.type === AST_NODE_TYPES.TSQualifiedName) {
+                    const { left, right } = typeName;
+                    if (left.type !== AST_NODE_TYPES.Identifier ||
+                        !isZodNamespace(left.name)) {
+                        return;
+                    }
+                    const usedStyle = right.name;
+                    if ((usedStyle !== 'infer' && usedStyle !== 'output') ||
+                        usedStyle === style) {
+                        return;
+                    }
+                    context.report({
+                        node: right,
+                        messageId: style === 'infer' ? 'useInfer' : 'useOutput',
+                        fix(fixer) {
+                            return fixer.replaceText(right, style);
+                        },
+                    });
+                    return;
+                }
+                if (typeName.type === AST_NODE_TYPES.Identifier) {
+                    const originalName = getNamedImportOriginal(typeName.name);
+                    if ((originalName !== 'infer' && originalName !== 'output') ||
+                        originalName === style) {
+                        return;
+                    }
+                    const targetLocalName = getNamedImportLocal(style);
+                    context.report({
+                        node: typeName,
+                        messageId: style === 'infer' ? 'useInfer' : 'useOutput',
+                        fix(fixer) {
+                            if (!targetLocalName || targetLocalName === 'infer') {
+                                return null;
+                            }
+                            return fixer.replaceText(typeName, targetLocalName);
+                        },
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/src/rules/consistent-schema-output-type-style.spec.d.ts

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

package/dist/src/rules/consistent-schema-output-type-style.spec.js

@@ -0,0 +1,128 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { consistentSchemaOutputTypeStyle } from './consistent-schema-output-type-style.js';
+const ruleTester = new RuleTester();
+ruleTester.run(`${consistentSchemaOutputTypeStyle.name} (output)`, consistentSchemaOutputTypeStyle, {
+    valid: [
+        {
+            name: 'namespace import',
+            code: dedent `
+          import * as z from 'zod/mini';
+          type SchemaType = z.output<typeof UserSchema>;
+        `,
+        },
+        {
+            name: 'named z import',
+            code: dedent `
+          import { z } from 'zod/mini';
+          type SchemaType = z.output<typeof UserSchema>;
+        `,
+        },
+        {
+            name: 'zod/v4-mini import',
+            code: dedent `
+          import * as z from 'zod/v4-mini';
+          type SchemaType = z.output<typeof UserSchema>;
+        `,
+        },
+        {
+            name: 'non-zod/mini import',
+            code: dedent `
+          import * as z from '@custom';
+          type SchemaType = z.infer<typeof UserSchema>;
+        `,
+        },
+        {
+            name: 'not triggered on zod import',
+            code: dedent `
+          import * as z from 'zod';
+          type SchemaType = z.infer<typeof UserSchema>;
+        `,
+        },
+    ],
+    invalid: [
+        {
+            name: 'namespace import',
+            code: dedent `
+          import * as z from 'zod/mini';
+          type SchemaType = z.infer<typeof UserSchema>;
+        `,
+            errors: [{ messageId: 'useOutput' }],
+            output: dedent `
+          import * as z from 'zod/mini';
+          type SchemaType = z.output<typeof UserSchema>;
+        `,
+        },
+        {
+            name: 'named z import',
+            code: dedent `
+          import { z } from 'zod/mini';
+          type SchemaType = z.infer<typeof UserSchema>;
+        `,
+            errors: [{ messageId: 'useOutput' }],
+            output: dedent `
+          import { z } from 'zod/mini';
+          type SchemaType = z.output<typeof UserSchema>;
+        `,
+        },
+        {
+            name: 'aliased namespace import',
+            code: dedent `
+          import * as myZ from 'zod/mini';
+          type SchemaType = myZ.infer<typeof UserSchema>;
+        `,
+            errors: [{ messageId: 'useOutput' }],
+            output: dedent `
+          import * as myZ from 'zod/mini';
+          type SchemaType = myZ.output<typeof UserSchema>;
+        `,
+        },
+        {
+            name: 'zod/v4-mini import',
+            code: dedent `
+          import * as z from 'zod/v4-mini';
+          type SchemaType = z.infer<typeof UserSchema>;
+        `,
+            errors: [{ messageId: 'useOutput' }],
+            output: dedent `
+          import * as z from 'zod/v4-mini';
+          type SchemaType = z.output<typeof UserSchema>;
+        `,
+        },
+    ],
+});
+ruleTester.run(`${consistentSchemaOutputTypeStyle.name} (infer)`, consistentSchemaOutputTypeStyle, {
+    valid: [
+        {
+            name: 'namespace import',
+            code: dedent `
+          import * as z from 'zod/mini';
+          type SchemaType = z.infer<typeof UserSchema>;
+        `,
+            options: [{ style: 'infer' }],
+        },
+        {
+            name: 'not triggered on zod import',
+            code: dedent `
+          import * as z from 'zod';
+          type SchemaType = z.output<typeof UserSchema>;
+        `,
+            options: [{ style: 'infer' }],
+        },
+    ],
+    invalid: [
+        {
+            name: 'namespace import',
+            code: dedent `
+          import * as z from 'zod/mini';
+          type SchemaType = z.output<typeof UserSchema>;
+        `,
+            options: [{ style: 'infer' }],
+            errors: [{ messageId: 'useInfer' }],
+            output: dedent `
+          import * as z from 'zod/mini';
+          type SchemaType = z.infer<typeof UserSchema>;
+        `,
+        },
+    ],
+});

package/dist/src/rules/consistent-schema-var-name.d.ts

@@ -0,0 +1,10 @@
+interface Options {
+    before?: string;
+    after?: string;
+}
+export declare const consistentSchemaVarName: import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidName", [Options], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export {};

package/dist/src/rules/consistent-schema-var-name.js

@@ -0,0 +1,86 @@
+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 consistentSchemaVarName = createZodMiniPluginRule({
+    name: 'consistent-schema-var-name',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            zodImportAllowedSource,
+            description: 'Enforce a consistent naming convention for Zod Mini schema variables',
+        },
+        messages: {
+            invalidName: 'Rename this Zod Mini schema to "{{expected}}"',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    before: {
+                        type: 'string',
+                        description: 'The required prefix for Zod Mini schema variables',
+                    },
+                    after: {
+                        type: 'string',
+                        description: 'The required suffix for Zod Mini schema variables',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{ after: 'Schema' }],
+    create(context, [{ before = '', after = '' }]) {
+        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) {
+                    return;
+                }
+                const { name } = node.id;
+                const validPrefix = !before || name.startsWith(before);
+                const validSuffix = !after || name.endsWith(after);
+                if (validPrefix && validSuffix) {
+                    return;
+                }
+                const expected = (validPrefix ? '' : before) + name + (validSuffix ? '' : after);
+                context.report({
+                    node,
+                    messageId: 'invalidName',
+                    data: { expected },
+                });
+            },
+        };
+    },
+});

package/dist/src/rules/consistent-schema-var-name.spec.d.ts

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

package/dist/src/rules/consistent-schema-var-name.spec.js

@@ -0,0 +1,130 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { consistentSchemaVarName } from './consistent-schema-var-name.js';
+const ruleTester = new RuleTester();
+ruleTester.run(consistentSchemaVarName.name, consistentSchemaVarName, {
+    valid: [
+        {
+            name: 'valid (default suffix)',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const userSchema = z.string();
+      `,
+        },
+        {
+            name: 'named import',
+            code: dedent `
+        import { string } from 'zod/mini';
+        const userSchema = string();
+      `,
+        },
+        {
+            name: 'named z import',
+            code: dedent `
+        import { z } from 'zod/mini';
+        const userSchema = z.string();
+      `,
+        },
+        {
+            name: 'with parse()',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const value = z.string().parse("asd")
+      `,
+        },
+        {
+            name: 'ignores non-zod/mini',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const myVar = 1
+      `,
+        },
+        {
+            name: 'not triggered on zod import',
+            code: dedent `
+        import * as z from 'zod';
+        const myVar = z.string();
+      `,
+        },
+        {
+            name: 'custom suffix',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const userVar = z.string();
+      `,
+            options: [{ after: 'Var' }],
+        },
+        {
+            name: 'prefix only',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const $user = z.string();
+      `,
+            options: [{ before: '$', after: '' }],
+        },
+        {
+            name: 'both prefix and suffix',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const $userSchema = z.string();
+      `,
+            options: [{ before: '$', after: 'Schema' }],
+        },
+        {
+            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: 'invalidName', data: { expected: 'myVarSchema' } }],
+            output: null,
+        },
+        {
+            name: 'named import (missing suffix)',
+            code: dedent `
+        import { string } from 'zod/mini';
+        const myVar = string();
+      `,
+            errors: [{ messageId: 'invalidName', data: { expected: 'myVarSchema' } }],
+            output: null,
+        },
+        {
+            name: 'missing prefix only',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const user = z.string();
+      `,
+            options: [{ before: '$', after: '' }],
+            errors: [{ messageId: 'invalidName', data: { expected: '$user' } }],
+            output: null,
+        },
+        {
+            name: 'missing both prefix and suffix',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const user = z.string();
+      `,
+            options: [{ before: '$', after: 'Schema' }],
+            errors: [{ messageId: 'invalidName', data: { expected: '$userSchema' } }],
+            output: null,
+        },
+        {
+            name: 'zod/v4-mini import (missing suffix)',
+            code: dedent `
+        import * as z from 'zod/v4-mini';
+        const myVar = z.string();
+      `,
+            errors: [{ messageId: 'invalidName', data: { expected: 'myVarSchema' } }],
+            output: null,
+        },
+    ],
+});

package/dist/src/rules/no-any-schema.d.ts

@@ -0,0 +1,6 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export declare const noAnySchema: TSESLint.RuleModule<"noZAny" | "useUnknown", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, TSESLint.RuleListener> & {
+    name: string;
+};

package/dist/src/rules/no-any-schema.js

@@ -0,0 +1,65 @@
+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 noAnySchema = createZodMiniPluginRule({
+    name: 'no-any-schema',
+    meta: {
+        hasSuggestions: true,
+        type: 'suggestion',
+        docs: {
+            zodImportAllowedSource,
+            description: 'Disallow usage of `z.any()` in Zod Mini schemas',
+        },
+        messages: {
+            noZAny: 'Using `z.any()` is not allowed. Please use a more specific schema.',
+            useUnknown: 'Replace `z.any()` with `z.unknown()`',
+        },
+        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) !== 'any') {
+                    return;
+                }
+                const { callee } = node;
+                if (callee.type === AST_NODE_TYPES.Identifier) {
+                    context.report({
+                        node,
+                        messageId: 'noZAny',
+                    });
+                    return;
+                }
+                if (callee.type === AST_NODE_TYPES.MemberExpression) {
+                    const [{ node: schemaMethod }] = collectZodChainMethods(node);
+                    const schemaMethodCallee = schemaMethod.callee;
+                    if (schemaMethodCallee.type === AST_NODE_TYPES.MemberExpression &&
+                        schemaMethodCallee.property.type === AST_NODE_TYPES.Identifier) {
+                        context.report({
+                            node,
+                            messageId: 'noZAny',
+                            suggest: [
+                                {
+                                    messageId: 'useUnknown',
+                                    fix(fixer) {
+                                        return fixer.replaceText(schemaMethodCallee.property, 'unknown');
+                                    },
+                                },
+                            ],
+                        });
+                        return;
+                    }
+                    context.report({
+                        node,
+                        messageId: 'noZAny',
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/src/rules/no-any-schema.spec.d.ts

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