eslint-plugin-zod-mini 0.1.0

package/dist/src/rules/prefer-namespace-import.js

@@ -0,0 +1,146 @@
+import { isZodImportSource } from '@eslint-zod/utils';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { createZodMiniPluginRule } from '../utils/create-plugin-rule.js';
+function isGroupFirstImportTypeNamespace(group) {
+    const { hasOnlyTypeImports, nodes: [firstImportNode], } = group;
+    const { specifiers } = firstImportNode;
+    if (specifiers.length === 1 &&
+        specifiers[0].type === AST_NODE_TYPES.ImportNamespaceSpecifier) {
+        if (hasOnlyTypeImports) {
+            if (firstImportNode.importKind === 'type') {
+                return true;
+            }
+        }
+        else {
+            return true;
+        }
+    }
+    return false;
+}
+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 preferNamespaceImport = createZodMiniPluginRule({
+    name: 'prefer-namespace-import',
+    meta: {
+        type: 'suggestion',
+        deprecated: {
+            message: "Use `zod-mini/consistent-import` with `{ syntax: 'namespace' }`",
+        },
+        docs: {
+            zodImportAllowedSource: 'zod-mini',
+            description: "Enforce importing zod/mini as a namespace import (`import * as z from 'zod/mini'`)",
+        },
+        fixable: 'code',
+        messages: {
+            useNamespace: 'Import Zod Mini with a namespace import',
+            removeDuplicate: 'Zod Mini is already imported via namespace import',
+            convertUsage: 'Convert to namespace usage',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        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 = isGroupFirstImportTypeNamespace(importGroup);
+                    if (!isFirstImportValid) {
+                        context.report({
+                            node: firstImportNode,
+                            messageId: 'useNamespace',
+                            fix(fixer) {
+                                const importTypeKeyword = hasOnlyTypeImports ? 'type ' : '';
+                                const newImportText = `import ${importTypeKeyword}* as ${namespaceAliasName} 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',
+                                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/prefer-namespace-import.spec.d.ts

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

package/dist/src/rules/prefer-namespace-import.spec.js

@@ -0,0 +1,100 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferNamespaceImport } from './prefer-namespace-import.js';
+const ruleTester = new RuleTester();
+ruleTester.run(preferNamespaceImport.name, preferNamespaceImport, {
+    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 is valid',
+            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: 'useNamespace' }],
+            output: dedent `
+        import * as z from "zod/mini";
+        const userSchema = z.string();
+      `,
+        },
+        {
+            name: 'default import',
+            code: 'import z from "zod/mini";',
+            errors: [{ messageId: 'useNamespace' }],
+            output: 'import * as z from "zod/mini";',
+        },
+        {
+            name: 'multiple named imports',
+            code: 'import { object, string } from "zod/mini";',
+            errors: [{ messageId: 'useNamespace' }],
+            output: 'import * as z from "zod/mini";',
+        },
+        {
+            name: 'named type import',
+            code: 'import type { z } from "zod/mini";',
+            errors: [{ messageId: 'useNamespace' }],
+            output: 'import type * as z from "zod/mini";',
+        },
+        {
+            name: 'zod/v4-mini default import',
+            code: 'import z from "zod/v4-mini";',
+            errors: [{ messageId: 'useNamespace' }],
+            output: 'import * as z from "zod/v4-mini";',
+        },
+        {
+            name: 'named imports (one value and one type)',
+            code: dedent `
+        import { z } from "zod/mini";
+        import type { $ZodType } from "zod/mini";
+        const userSchema: $ZodType = z.string();
+      `,
+            errors: [
+                { messageId: 'useNamespace', line: 1 },
+                { messageId: 'removeDuplicate', line: 2 },
+                { messageId: 'convertUsage', 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: 'useNamespace', line: 1 }],
+            output: dedent `
+        import * as myZod from "zod/mini";
+        const userSchema = myZod.string();
+      `,
+        },
+    ],
+});

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

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

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

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

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

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

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

@@ -0,0 +1,157 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { requireBrandTypeParameter } from './require-brand-type-parameter.js';
+const ruleTester = new RuleTester();
+ruleTester.run(requireBrandTypeParameter.name, requireBrandTypeParameter, {
+    valid: [
+        {
+            name: 'namespace with type parameter',
+            code: dedent `
+        import * as z from 'zod/mini'
+        z.string().brand<"id">();
+      `,
+        },
+        {
+            name: 'named import with type parameter',
+            code: dedent `
+        import { string } from 'zod/mini'
+        string().brand<"id">();
+      `,
+        },
+        {
+            name: 'named z import with type parameter',
+            code: dedent `
+        import { z } from 'zod/mini'
+        z.string().brand<"id">();
+      `,
+        },
+        {
+            name: 'no error on other brand function',
+            code: dedent `
+        import * as z from 'zod/mini'
+        another.brand();
+      `,
+        },
+        {
+            name: 'not triggered on zod import',
+            code: dedent `
+        import * as z from 'zod';
+        z.string().brand();
+      `,
+        },
+        {
+            name: 'complex chain',
+            code: dedent `
+        import * as z from 'zod/mini'
+        z.string().check(z.min(1), z.max(10)).brand<"email">();
+      `,
+        },
+    ],
+    invalid: [
+        {
+            name: 'namespace import',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.string().brand();
+      `,
+            errors: [
+                {
+                    messageId: 'missingTypeParameter',
+                    suggestions: [
+                        {
+                            messageId: 'removeBrandFunction',
+                            output: dedent `
+                import * as z from 'zod/mini';
+                z.string();
+              `,
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            name: 'named import',
+            code: dedent `
+        import { string } from 'zod/mini';
+        string().brand();
+      `,
+            errors: [
+                {
+                    messageId: 'missingTypeParameter',
+                    suggestions: [
+                        {
+                            messageId: 'removeBrandFunction',
+                            output: dedent `
+                import { string } from 'zod/mini';
+                string();
+              `,
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            name: 'named z import',
+            code: dedent `
+        import { z } from 'zod/mini';
+        z.string().brand();
+      `,
+            errors: [
+                {
+                    messageId: 'missingTypeParameter',
+                    suggestions: [
+                        {
+                            messageId: 'removeBrandFunction',
+                            output: dedent `
+                import { z } from 'zod/mini';
+                z.string();
+              `,
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            name: 'zod/v4-mini import',
+            code: dedent `
+        import * as z from 'zod/v4-mini';
+        z.string().brand();
+      `,
+            errors: [
+                {
+                    messageId: 'missingTypeParameter',
+                    suggestions: [
+                        {
+                            messageId: 'removeBrandFunction',
+                            output: dedent `
+                import * as z from 'zod/v4-mini';
+                z.string();
+              `,
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            name: 'complex chain without type parameter',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.string().check(z.min(1)).brand()
+      `,
+            errors: [
+                {
+                    messageId: 'missingTypeParameter',
+                    suggestions: [
+                        {
+                            messageId: 'removeBrandFunction',
+                            output: dedent `
+                import * as z from 'zod/mini';
+                z.string().check(z.min(1))
+              `,
+                        },
+                    ],
+                },
+            ],
+        },
+    ],
+});

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

@@ -0,0 +1,5 @@
+export declare const requireErrorMessage: import("@typescript-eslint/utils/ts-eslint").RuleModule<"requireErrorMessage" | "preferError" | "removeMessage", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};

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

@@ -0,0 +1,103 @@
+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 requireErrorMessage = createZodMiniPluginRule({
+    name: 'require-error-message',
+    meta: {
+        type: 'suggestion',
+        fixable: 'code',
+        docs: {
+            zodImportAllowedSource,
+            description: 'Enforce that custom refinements include an error message',
+        },
+        messages: {
+            requireErrorMessage: 'Custom refinements must include an error message',
+            preferError: 'Use the "error" property instead of the deprecated "message" property',
+            removeMessage: 'The "message" property is deprecated; use "error"',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
+        return {
+            ImportDeclaration: importDeclarationListener,
+            CallExpression(node) {
+                const zodSchemaMeta = detectZodSchemaRootNode(node);
+                if (!zodSchemaMeta) {
+                    return;
+                }
+                const refines = collectZodChainMethods(node).filter((it) => it.name === 'refine' || it.name === 'custom');
+                if (refines.length === 0) {
+                    return;
+                }
+                for (const refine of refines) {
+                    const refineNode = refine.node;
+                    if (refineNode.arguments.length < 2) {
+                        context.report({
+                            messageId: 'requireErrorMessage',
+                            node: refineNode,
+                        });
+                        continue;
+                    }
+                    const [, params] = refineNode.arguments;
+                    if (params.type === AST_NODE_TYPES.Literal) {
+                        continue;
+                    }
+                    if (params.type !== AST_NODE_TYPES.ObjectExpression) {
+                        continue;
+                    }
+                    let errorPropertyNode;
+                    let messagePropertyNode;
+                    for (const property of params.properties) {
+                        if (property.type === AST_NODE_TYPES.Property &&
+                            property.key.type === AST_NODE_TYPES.Identifier) {
+                            if (property.key.name === 'error') {
+                                errorPropertyNode = property;
+                            }
+                            if (property.key.name === 'message') {
+                                messagePropertyNode = property;
+                            }
+                            if (errorPropertyNode && messagePropertyNode) {
+                                break;
+                            }
+                        }
+                    }
+                    if (errorPropertyNode && messagePropertyNode) {
+                        context.report({
+                            messageId: 'removeMessage',
+                            node: messagePropertyNode,
+                            fix(fixer) {
+                                const { sourceCode } = context;
+                                const nextToken = sourceCode.getTokenAfter(messagePropertyNode);
+                                let [, end] = messagePropertyNode.range;
+                                if ((nextToken === null || nextToken === void 0 ? void 0 : nextToken.value) === ',') {
+                                    end = nextToken.range[1];
+                                }
+                                return fixer.removeRange([messagePropertyNode.range[0], end]);
+                            },
+                        });
+                        continue;
+                    }
+                    if (messagePropertyNode && !errorPropertyNode) {
+                        context.report({
+                            messageId: 'preferError',
+                            node: params,
+                            fix(fixer) {
+                                return fixer.replaceTextRange(messagePropertyNode.key.range, 'error');
+                            },
+                        });
+                        continue;
+                    }
+                    if (!errorPropertyNode) {
+                        context.report({
+                            messageId: 'requireErrorMessage',
+                            node: params,
+                        });
+                    }
+                }
+            },
+        };
+    },
+});

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

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