eslint-plugin-zod-mini 0.1.0

package/dist/src/rules/consistent-import-source.spec.js

@@ -0,0 +1,103 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import { consistentImportSource } from './consistent-import-source.js';
+const ruleTester = new RuleTester();
+ruleTester.run(consistentImportSource.name, consistentImportSource, {
+    valid: [
+        { code: 'import * as z from "zod/mini"' },
+        { code: 'import { z } from "zod/mini"' },
+        { code: 'import z from "zod/mini"' },
+        {
+            code: 'import z from "zod/mini"',
+            options: [{ sources: ['zod/mini'] }],
+        },
+        {
+            code: 'import z from "zod/v4-mini"',
+            options: [{ sources: ['zod/v4-mini'] }],
+        },
+        {
+            code: 'import z from "zod"',
+            options: [{ sources: ['zod'] }],
+        },
+        {
+            name: 'non-zod import is ignored',
+            code: 'import z from "react"',
+        },
+    ],
+    invalid: [
+        {
+            name: 'zod not allowed by default',
+            code: 'import * as z from "zod"',
+            errors: [
+                {
+                    messageId: 'sourceNotAllowed',
+                    data: { source: 'zod', sources: '"zod/mini"' },
+                    suggestions: [
+                        {
+                            messageId: 'replaceSource',
+                            data: { valid: 'zod/mini', invalid: 'zod' },
+                            output: 'import * as z from "zod/mini"',
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            name: 'zod/v4 not allowed by default',
+            code: 'import z from "zod/v4"',
+            errors: [
+                {
+                    messageId: 'sourceNotAllowed',
+                    data: { source: 'zod/v4', sources: '"zod/mini"' },
+                    suggestions: [
+                        {
+                            messageId: 'replaceSource',
+                            data: { valid: 'zod/mini', invalid: 'zod/v4' },
+                            output: 'import z from "zod/mini"',
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            name: 'should keep quote style',
+            code: "import z from 'zod/v4-mini'",
+            options: [{ sources: ['zod/mini'] }],
+            errors: [
+                {
+                    messageId: 'sourceNotAllowed',
+                    data: { source: 'zod/v4-mini', sources: '"zod/mini"' },
+                    suggestions: [
+                        {
+                            messageId: 'replaceSource',
+                            data: { valid: 'zod/mini', invalid: 'zod/v4-mini' },
+                            output: "import z from 'zod/mini'",
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            name: 'multiple sources, multiple suggestions',
+            code: 'import z from "zod"',
+            options: [{ sources: ['zod/mini', 'zod/v4-mini'] }],
+            errors: [
+                {
+                    messageId: 'sourceNotAllowed',
+                    data: { source: 'zod', sources: '"zod/mini", "zod/v4-mini"' },
+                    suggestions: [
+                        {
+                            messageId: 'replaceSource',
+                            data: { valid: 'zod/mini', invalid: 'zod' },
+                            output: 'import z from "zod/mini"',
+                        },
+                        {
+                            messageId: 'replaceSource',
+                            data: { valid: 'zod/v4-mini', invalid: 'zod' },
+                            output: 'import z from "zod/v4-mini"',
+                        },
+                    ],
+                },
+            ],
+        },
+    ],
+});

package/dist/src/rules/consistent-import.d.ts

@@ -0,0 +1,12 @@
+declare const IMPORT_SYNTAXES: readonly ["namespace", "named"];
+type ImportSyntax = (typeof IMPORT_SYNTAXES)[number];
+interface Options {
+    syntax: ImportSyntax;
+}
+type MessageIds = 'changeImportSyntax' | 'removeDuplicate' | 'convertUsage';
+export declare const consistentImport: 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-import.js

@@ -0,0 +1,176 @@
+import { isZodImportSource } from '@eslint-zod/utils';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { createZodMiniPluginRule } from '../utils/create-plugin-rule.js';
+const IMPORT_SYNTAXES = ['namespace', 'named'];
+function isGroupFirstImportKindValidForSyntax(group, syntax) {
+    const { hasOnlyTypeImports, nodes } = group;
+    const [firstImportNode] = nodes;
+    const { specifiers, importKind } = firstImportNode;
+    if (specifiers.length !== 1) {
+        return false;
+    }
+    const [specifier] = specifiers;
+    const isValidForSyntax = syntax === 'named'
+        ? specifier.type === AST_NODE_TYPES.ImportSpecifier &&
+            specifier.imported.type === AST_NODE_TYPES.Identifier &&
+            specifier.imported.name === 'z'
+        : specifier.type === AST_NODE_TYPES.ImportNamespaceSpecifier;
+    if (!isValidForSyntax) {
+        return false;
+    }
+    if (hasOnlyTypeImports) {
+        return importKind === 'type';
+    }
+    return true;
+}
+function shouldIdentifierBeRenamed(node) {
+    if (node.parent.type === AST_NODE_TYPES.ImportSpecifier) {
+        return false;
+    }
+    if (node.parent.type === AST_NODE_TYPES.MemberExpression &&
+        node.parent.object.type === AST_NODE_TYPES.Identifier &&
+        node.parent.object.name !== node.name) {
+        return false;
+    }
+    return true;
+}
+function getNamespaceAliasNameFrom(node) {
+    if (node.type === AST_NODE_TYPES.ImportDefaultSpecifier ||
+        node.type === AST_NODE_TYPES.ImportNamespaceSpecifier) {
+        return node.local.name;
+    }
+    if (node.imported.type === AST_NODE_TYPES.Identifier &&
+        node.imported.name === 'z') {
+        return node.local.name;
+    }
+    return null;
+}
+export const consistentImport = createZodMiniPluginRule({
+    name: 'consistent-import',
+    meta: {
+        type: 'problem',
+        docs: {
+            zodImportAllowedSource: 'zod-mini',
+            description: 'Enforce a consistent import style for Zod Mini',
+        },
+        fixable: 'code',
+        messages: {
+            changeImportSyntax: 'Use a {{syntax}} import for Zod Mini.',
+            removeDuplicate: 'Remove duplicate Zod Mini import; Zod Mini is already imported.',
+            convertUsage: 'Update Zod Mini usage to match the {{syntax}} import syntax.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    syntax: {
+                        description: 'Specifies the import syntax to use for Zod Mini.',
+                        type: 'string',
+                        enum: IMPORT_SYNTAXES,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{ syntax: 'namespace' }],
+    create(context, [options]) {
+        const { syntax } = options;
+        const { sourceCode } = context;
+        const importGroups = {};
+        return {
+            ImportDeclaration(node) {
+                const { source, importKind } = node;
+                if (!isZodImportSource(source.value, 'zod-mini')) {
+                    return;
+                }
+                if (!importGroups[source.value]) {
+                    importGroups[source.value] = {
+                        hasOnlyTypeImports: true,
+                        nodes: [],
+                    };
+                }
+                if (importGroups[source.value].hasOnlyTypeImports &&
+                    importKind === 'value') {
+                    importGroups[source.value].hasOnlyTypeImports = false;
+                }
+                importGroups[source.value].nodes.push(node);
+            },
+            'Program:exit': function () {
+                let namespaceAliasNameIndex = 0;
+                for (const importGroup of Object.values(importGroups)) {
+                    const { hasOnlyTypeImports, nodes } = importGroup;
+                    const [firstImportNode, ...othersImportNodes] = nodes;
+                    const nodesWithVariablesToUpdate = [];
+                    let namespaceAliasName = null;
+                    for (const specifier of nodes.flatMap((it) => it.specifiers)) {
+                        if (!namespaceAliasName) {
+                            namespaceAliasName = getNamespaceAliasNameFrom(specifier);
+                            if (namespaceAliasName) {
+                                continue;
+                            }
+                        }
+                        nodesWithVariablesToUpdate.push(specifier);
+                    }
+                    if (!namespaceAliasName) {
+                        namespaceAliasName = 'z';
+                        if (namespaceAliasNameIndex > 0) {
+                            namespaceAliasName = `z${namespaceAliasNameIndex}`;
+                            namespaceAliasNameIndex += 1;
+                        }
+                    }
+                    const isFirstImportValid = isGroupFirstImportKindValidForSyntax(importGroup, syntax);
+                    if (!isFirstImportValid) {
+                        context.report({
+                            node: firstImportNode,
+                            messageId: 'changeImportSyntax',
+                            data: { syntax },
+                            fix(fixer) {
+                                const importTypeKeyword = hasOnlyTypeImports ? 'type ' : '';
+                                let importSpecifier;
+                                if (syntax === 'named') {
+                                    if (namespaceAliasName === 'z') {
+                                        importSpecifier = '{ z }';
+                                    }
+                                    else {
+                                        importSpecifier = `{ z as ${namespaceAliasName} }`;
+                                    }
+                                }
+                                else {
+                                    importSpecifier = `* as ${namespaceAliasName}`;
+                                }
+                                const newImportText = `import ${importTypeKeyword}${importSpecifier} from ${firstImportNode.source.raw};`;
+                                return fixer.replaceText(firstImportNode, newImportText);
+                            },
+                        });
+                    }
+                    const allVariables = nodesWithVariablesToUpdate.flatMap((it) => sourceCode.getDeclaredVariables(it));
+                    const allReferences = allVariables.flatMap((it) => it.references);
+                    for (const ref of allReferences) {
+                        const { identifier } = ref;
+                        if (shouldIdentifierBeRenamed(identifier)) {
+                            context.report({
+                                node: identifier,
+                                messageId: 'convertUsage',
+                                data: { syntax },
+                                fix(fixer) {
+                                    const newId = `${namespaceAliasName}.${identifier.name}`;
+                                    return fixer.replaceText(identifier, newId);
+                                },
+                            });
+                        }
+                    }
+                    for (const extraImport of othersImportNodes) {
+                        context.report({
+                            node: extraImport,
+                            messageId: 'removeDuplicate',
+                            fix(fixer) {
+                                return fixer.removeRange(extraImport.range);
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/src/rules/consistent-import.spec.d.ts

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

package/dist/src/rules/consistent-import.spec.js

@@ -0,0 +1,194 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { consistentImport } from './consistent-import.js';
+const ruleTester = new RuleTester();
+ruleTester.run(`${consistentImport.name} namespace`, consistentImport, {
+    valid: [
+        {
+            name: 'namespace import',
+            code: 'import * as z from "zod/mini";',
+        },
+        {
+            name: 'aliased namespace import',
+            code: 'import * as myZod from "zod/mini";',
+        },
+        {
+            name: 'type namespace import',
+            code: 'import type * as myZod from "zod/mini";',
+        },
+        {
+            name: 'unrelated imports',
+            code: 'import { useState } from "react";',
+        },
+        {
+            name: 'zod/v4-mini namespace import',
+            code: 'import * as z from "zod/v4-mini";',
+        },
+        {
+            name: 'not triggered on zod import',
+            code: 'import { z } from "zod";',
+        },
+    ],
+    invalid: [
+        {
+            name: 'named import',
+            code: dedent `
+        import { z } from "zod/mini";
+        const userSchema = z.string();
+      `,
+            errors: [
+                { messageId: 'changeImportSyntax', data: { syntax: 'namespace' } },
+            ],
+            output: dedent `
+        import * as z from "zod/mini";
+        const userSchema = z.string();
+      `,
+        },
+        {
+            name: 'default import',
+            code: 'import z from "zod/mini";',
+            errors: [
+                { messageId: 'changeImportSyntax', data: { syntax: 'namespace' } },
+            ],
+            output: 'import * as z from "zod/mini";',
+        },
+        {
+            name: 'multiple named imports',
+            code: 'import { object, string } from "zod/mini";',
+            errors: [
+                { messageId: 'changeImportSyntax', data: { syntax: 'namespace' } },
+            ],
+            output: 'import * as z from "zod/mini";',
+        },
+        {
+            name: 'named type import',
+            code: 'import type { z } from "zod/mini";',
+            errors: [
+                { messageId: 'changeImportSyntax', data: { syntax: 'namespace' } },
+            ],
+            output: 'import type * as z from "zod/mini";',
+        },
+        {
+            name: 'zod/v4-mini default import',
+            code: 'import z from "zod/v4-mini";',
+            errors: [
+                { messageId: 'changeImportSyntax', data: { syntax: 'namespace' } },
+            ],
+            output: 'import * as z from "zod/v4-mini";',
+        },
+        {
+            name: 'named imports with type',
+            code: dedent `
+        import { z } from "zod/mini";
+        import type { $ZodType } from "zod/mini";
+        const userSchema: $ZodType = z.string();
+      `,
+            errors: [
+                {
+                    messageId: 'changeImportSyntax',
+                    data: { syntax: 'namespace' },
+                    line: 1,
+                },
+                {
+                    messageId: 'removeDuplicate',
+                    data: { syntax: 'namespace' },
+                    line: 2,
+                },
+                { messageId: 'convertUsage', data: { syntax: 'namespace' }, line: 3 },
+            ],
+            output: dedent `
+        import * as z from "zod/mini";
+
+        const userSchema: z.$ZodType = z.string();
+      `,
+        },
+        {
+            name: 'keeps name from named z import',
+            code: dedent `
+        import { z as myZod } from "zod/mini";
+        const userSchema = myZod.string();
+      `,
+            errors: [{ messageId: 'changeImportSyntax', line: 1 }],
+            output: dedent `
+        import * as myZod from "zod/mini";
+        const userSchema = myZod.string();
+      `,
+        },
+        {
+            name: 'two named imports from same module',
+            code: dedent `
+        import { array, boolean } from 'zod/mini';
+        const userSchema = array(boolean())
+      `,
+            errors: [
+                { messageId: 'changeImportSyntax', line: 1 },
+                { messageId: 'convertUsage', line: 2 },
+                { messageId: 'convertUsage', line: 2 },
+            ],
+            output: dedent `
+        import * as z from 'zod/mini';
+        const userSchema = z.array(z.boolean())
+      `,
+        },
+    ],
+});
+ruleTester.run(`${consistentImport.name} named`, consistentImport, {
+    valid: [
+        {
+            name: 'valid named import',
+            options: [{ syntax: 'named' }],
+            code: dedent `
+        import { z } from 'zod/mini';
+        const userSchema = z.string();
+      `,
+        },
+        {
+            name: 'unrelated imports',
+            code: 'import { useState } from "react";',
+        },
+    ],
+    invalid: [
+        {
+            name: 'default import',
+            options: [{ syntax: 'named' }],
+            code: dedent `
+        import z from 'zod/mini';
+        const userSchema = z.string();
+      `,
+            errors: [{ messageId: 'changeImportSyntax', data: { syntax: 'named' } }],
+            output: dedent `
+        import { z } from 'zod/mini';
+        const userSchema = z.string();
+      `,
+        },
+        {
+            name: 'namespace import',
+            options: [{ syntax: 'named' }],
+            code: dedent `
+        import * as z from 'zod/mini';
+        const userSchema = z.string();
+      `,
+            errors: [{ messageId: 'changeImportSyntax', data: { syntax: 'named' } }],
+            output: dedent `
+        import { z } from 'zod/mini';
+        const userSchema = z.string();
+      `,
+        },
+        {
+            name: 'individual named imports converted to z',
+            options: [{ syntax: 'named' }],
+            code: dedent `
+        import { string } from 'zod/mini';
+        const userSchema = string();
+      `,
+            errors: [
+                { messageId: 'changeImportSyntax', data: { syntax: 'named' } },
+                { messageId: 'convertUsage', data: { syntax: 'named' } },
+            ],
+            output: dedent `
+        import { z } from 'zod/mini';
+        const userSchema = z.string();
+      `,
+        },
+    ],
+});

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

@@ -0,0 +1,13 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+declare const ZOD_OBJECT_METHODS: readonly ["object", "looseObject", "strictObject"];
+type ZodObjectMethod = (typeof ZOD_OBJECT_METHODS)[number];
+interface Options {
+    allow: Array<ZodObjectMethod>;
+}
+type MessageIds = 'consistentMethod' | 'useMethod';
+export declare const consistentObjectSchemaType: TSESLint.RuleModule<MessageIds, [Options], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, TSESLint.RuleListener> & {
+    name: string;
+};
+export {};

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

@@ -0,0 +1,82 @@
+import { createZodSchemaImportTrack } from '@eslint-zod/utils';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { createZodMiniPluginRule } from '../utils/create-plugin-rule.js';
+const ZOD_OBJECT_METHODS = ['object', 'looseObject', 'strictObject'];
+const defaultOptions = { allow: ['object'] };
+const { zodImportAllowedSource, trackZodSchemaImports, } = createZodSchemaImportTrack('zod-mini');
+export const consistentObjectSchemaType = createZodMiniPluginRule({
+    name: 'consistent-object-schema-type',
+    meta: {
+        hasSuggestions: true,
+        type: 'suggestion',
+        docs: {
+            zodImportAllowedSource,
+            description: 'Enforce consistent usage of Zod Mini schema methods',
+        },
+        messages: {
+            consistentMethod: "Inconsistent Zod Mini object schema method '{{actual}}'. Allowed: {{allowedList}}.",
+            useMethod: "Replace with '{{expected}}'.",
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allow: {
+                        type: 'array',
+                        description: 'Decides which object methods are allowed',
+                        items: {
+                            type: 'string',
+                            enum: [...ZOD_OBJECT_METHODS],
+                        },
+                        minItems: 1,
+                        uniqueItems: true,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [defaultOptions],
+    create(context, [{ allow: allowedList }]) {
+        const { importDeclarationListener, detectZodSchemaRootNode, } = trackZodSchemaImports();
+        return {
+            ImportDeclaration: importDeclarationListener,
+            CallExpression(node) {
+                const zodSchemaMeta = detectZodSchemaRootNode(node);
+                const schemaType = zodSchemaMeta === null || zodSchemaMeta === void 0 ? void 0 : zodSchemaMeta.schemaType;
+                if (!schemaType || !ZOD_OBJECT_METHODS.includes(schemaType)) {
+                    return;
+                }
+                if (allowedList.includes(schemaType)) {
+                    return;
+                }
+                const { callee } = node;
+                if (callee.type === AST_NODE_TYPES.Identifier) {
+                    context.report({
+                        node,
+                        messageId: 'consistentMethod',
+                        data: { actual: schemaType, allowedList: allowedList.join(',') },
+                    });
+                    return;
+                }
+                if (callee.type === AST_NODE_TYPES.MemberExpression) {
+                    context.report({
+                        node,
+                        messageId: 'consistentMethod',
+                        data: {
+                            actual: schemaType,
+                            allowedList: allowedList.join(','),
+                        },
+                        suggest: allowedList.map((it) => ({
+                            messageId: 'useMethod',
+                            data: { expected: it },
+                            fix(fixer) {
+                                return fixer.replaceText(callee.property, it);
+                            },
+                        })),
+                    });
+                }
+            },
+        };
+    },
+});

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

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