eslint-plugin-zod-mini 0.1.0

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

@@ -0,0 +1,155 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { noAnySchema } from './no-any-schema.js';
+const ruleTester = new RuleTester();
+ruleTester.run(noAnySchema.name, noAnySchema, {
+    valid: [
+        {
+            name: 'not triggered with another schema',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const userSchema = z.string();
+      `,
+        },
+        {
+            name: 'named z import',
+            code: dedent `
+        import { z } from 'zod/mini';
+        const userSchema = z.string();
+      `,
+        },
+        {
+            name: 'nested schema declaration',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const userSchema = z.object({ name: z.string() });
+      `,
+        },
+        {
+            name: 'not zod',
+            code: 'something.any()',
+        },
+        {
+            name: 'not triggered on zod import',
+            code: dedent `
+        import * as z from 'zod';
+        const userSchema = z.any();
+      `,
+        },
+    ],
+    invalid: [
+        {
+            name: 'namespace import',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const userSchema = z.any();
+      `,
+            errors: [
+                {
+                    messageId: 'noZAny',
+                    suggestions: [
+                        {
+                            messageId: 'useUnknown',
+                            output: dedent `
+                import * as z from 'zod/mini';
+                const userSchema = z.unknown();
+              `,
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            name: 'named z import',
+            code: dedent `
+        import { z } from 'zod/mini';
+        const userSchema = z.any();
+      `,
+            errors: [
+                {
+                    messageId: 'noZAny',
+                    suggestions: [
+                        {
+                            messageId: 'useUnknown',
+                            output: dedent `
+                import { z } from 'zod/mini';
+                const userSchema = z.unknown();
+              `,
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            name: 'named import',
+            code: dedent `
+        import { any } from 'zod/mini';
+        const userSchema = any();
+      `,
+            errors: [{ messageId: 'noZAny' }],
+        },
+        {
+            name: 'namespace import within an object',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const userSchema = z.object({ prop: z.any() });
+      `,
+            errors: [
+                {
+                    messageId: 'noZAny',
+                    suggestions: [
+                        {
+                            messageId: 'useUnknown',
+                            output: dedent `
+                import * as z from 'zod/mini';
+                const userSchema = z.object({ prop: z.unknown() });
+              `,
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            name: 'zod/v4-mini import',
+            code: dedent `
+        import * as z from 'zod/v4-mini';
+        const userSchema = z.any();
+      `,
+            errors: [
+                {
+                    messageId: 'noZAny',
+                    suggestions: [
+                        {
+                            messageId: 'useUnknown',
+                            output: dedent `
+                import * as z from 'zod/v4-mini';
+                const userSchema = z.unknown();
+              `,
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            name: 'chained method',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const userSchema = z.any().check((value) => value)
+      `,
+            errors: [
+                {
+                    messageId: 'noZAny',
+                    suggestions: [
+                        {
+                            messageId: 'useUnknown',
+                            output: dedent `
+                import * as z from 'zod/mini';
+                const userSchema = z.unknown().check((value) => value)
+              `,
+                        },
+                    ],
+                },
+            ],
+        },
+    ],
+});

package/dist/src/rules/no-empty-custom-schema.d.ts

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

package/dist/src/rules/no-empty-custom-schema.js

@@ -0,0 +1,43 @@
+import { createZodSchemaImportTrack } from '@eslint-zod/utils';
+import { createZodMiniPluginRule } from '../utils/create-plugin-rule.js';
+const { zodImportAllowedSource, trackZodSchemaImports, } = createZodSchemaImportTrack('zod-mini');
+export const noEmptyCustomSchema = createZodMiniPluginRule({
+    name: 'no-empty-custom-schema',
+    meta: {
+        hasSuggestions: false,
+        type: 'suggestion',
+        docs: {
+            zodImportAllowedSource,
+            description: 'Disallow usage of `z.custom()` without arguments',
+        },
+        messages: {
+            noEmptyCustomSchema: 'You should provide a validate function within `z.custom()`',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
+        return {
+            ImportDeclaration: importDeclarationListener,
+            CallExpression(node) {
+                var _a;
+                const zodSchemaMeta = detectZodSchemaRootNode(node);
+                if (!zodSchemaMeta) {
+                    return;
+                }
+                if (zodSchemaMeta.schemaType !== 'custom') {
+                    return;
+                }
+                const chainMethods = collectZodChainMethods(node);
+                const customCallNode = (_a = chainMethods.find((method) => method.name === 'custom')) === null || _a === void 0 ? void 0 : _a.node;
+                if ((customCallNode === null || customCallNode === void 0 ? void 0 : customCallNode.arguments.length) === 0) {
+                    context.report({
+                        node: customCallNode,
+                        messageId: 'noEmptyCustomSchema',
+                    });
+                }
+            },
+        };
+    },
+});

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

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

package/dist/src/rules/no-empty-custom-schema.spec.js

@@ -0,0 +1,97 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { noEmptyCustomSchema } from './no-empty-custom-schema.js';
+const ruleTester = new RuleTester();
+ruleTester.run(noEmptyCustomSchema.name, noEmptyCustomSchema, {
+    valid: [
+        {
+            name: 'namespace with validator',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.custom((val) => typeof val === "string");
+      `,
+        },
+        {
+            name: 'named with validator',
+            code: dedent `
+        import { custom } from 'zod/mini';
+        custom((val) => typeof val === "string");
+      `,
+        },
+        {
+            name: 'type and function',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.custom<\`\${number}px\`>((val) => {
+          return typeof val === "string" ? /^\\d+px$/.test(val) : false;
+        });
+      `,
+        },
+        {
+            name: 'not triggered on zod import',
+            code: dedent `
+        import * as z from 'zod';
+        z.custom();
+      `,
+        },
+        {
+            name: 'custom wrapped with optional',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const userSchema = z.optional(
+          z.custom((val) => typeof val === 'string', { error: 'Error' })
+        );
+      `,
+        },
+    ],
+    invalid: [
+        {
+            name: 'namespace',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.custom();
+      `,
+            errors: [{ messageId: 'noEmptyCustomSchema' }],
+        },
+        {
+            name: 'named',
+            code: dedent `
+        import { custom } from 'zod/mini';
+        custom();
+      `,
+            errors: [{ messageId: 'noEmptyCustomSchema' }],
+        },
+        {
+            name: 'named z',
+            code: dedent `
+        import { z } from 'zod/mini';
+        z.custom();
+      `,
+            errors: [{ messageId: 'noEmptyCustomSchema' }],
+        },
+        {
+            name: 'type without function',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.custom<\`\${number}px\`>();
+      `,
+            errors: [{ messageId: 'noEmptyCustomSchema' }],
+        },
+        {
+            name: 'zod/v4-mini import',
+            code: dedent `
+        import * as z from 'zod/v4-mini';
+        z.custom();
+      `,
+            errors: [{ messageId: 'noEmptyCustomSchema' }],
+        },
+        {
+            name: 'wrapped with optional',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const userSchema = z.optional(z.custom());
+      `,
+            errors: [{ messageId: 'noEmptyCustomSchema' }],
+        },
+    ],
+});

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

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

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

@@ -0,0 +1,33 @@
+import { createZodSchemaImportTrack } from '@eslint-zod/utils';
+import { createZodMiniPluginRule } from '../utils/create-plugin-rule.js';
+const { zodImportAllowedSource, trackZodSchemaImports, } = createZodSchemaImportTrack('zod-mini');
+export const noUnknownSchema = createZodMiniPluginRule({
+    name: 'no-unknown-schema',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            zodImportAllowedSource,
+            description: 'Disallow usage of `z.unknown()` in Zod Mini schemas',
+        },
+        messages: {
+            noZUnknown: 'Using `z.unknown()` is not allowed. Please use a more specific schema.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const { importDeclarationListener, detectZodSchemaRootNode, } = trackZodSchemaImports();
+        return {
+            ImportDeclaration: importDeclarationListener,
+            CallExpression(node) {
+                const zodSchemaMeta = detectZodSchemaRootNode(node);
+                if ((zodSchemaMeta === null || zodSchemaMeta === void 0 ? void 0 : zodSchemaMeta.schemaType) === 'unknown') {
+                    context.report({
+                        node,
+                        messageId: 'noZUnknown',
+                    });
+                }
+            },
+        };
+    },
+});

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

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

package/dist/src/rules/no-unknown-schema.spec.js

@@ -0,0 +1,75 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { noUnknownSchema } from './no-unknown-schema.js';
+const ruleTester = new RuleTester();
+ruleTester.run(noUnknownSchema.name, noUnknownSchema, {
+    valid: [
+        {
+            name: 'with another zod/mini schema',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const userSchema = z.string();
+      `,
+        },
+        {
+            name: 'nested object',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const userSchema = z.object({ name: z.string() });
+      `,
+        },
+        {
+            name: 'not zod',
+            code: 'something.unknown()',
+        },
+        {
+            name: 'not triggered on zod import',
+            code: dedent `
+        import * as z from 'zod';
+        const userSchema = z.unknown();
+      `,
+        },
+    ],
+    invalid: [
+        {
+            name: 'namespace import',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const userSchema = z.unknown();
+      `,
+            errors: [{ messageId: 'noZUnknown' }],
+        },
+        {
+            name: 'named import',
+            code: dedent `
+        import { unknown } from 'zod/mini';
+        const userSchema = unknown();
+      `,
+            errors: [{ messageId: 'noZUnknown' }],
+        },
+        {
+            name: 'named z import',
+            code: dedent `
+        import { z } from 'zod/mini';
+        const userSchema = z.unknown();
+      `,
+            errors: [{ messageId: 'noZUnknown' }],
+        },
+        {
+            name: 'zod/v4-mini import',
+            code: dedent `
+        import * as z from 'zod/v4-mini';
+        const userSchema = z.unknown();
+      `,
+            errors: [{ messageId: 'noZUnknown' }],
+        },
+        {
+            name: 'inside an object',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const userSchema = z.object({ prop: z.unknown() });
+      `,
+            errors: [{ messageId: 'noZUnknown', line: 2, column: 37, endColumn: 48 }],
+        },
+    ],
+});

package/dist/src/rules/prefer-meta.d.ts

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

package/dist/src/rules/prefer-meta.js

@@ -0,0 +1,51 @@
+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 preferMeta = createZodMiniPluginRule({
+    name: 'prefer-meta',
+    meta: {
+        type: 'suggestion',
+        fixable: 'code',
+        docs: {
+            zodImportAllowedSource,
+            description: 'Enforce usage of `z.meta()` over `z.describe()`',
+        },
+        messages: {
+            preferMeta: 'The `z.describe()` function still exists for compatibility with Zod 3, but `z.meta()` is now the recommended approach.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const { importDeclarationListener, isZodNamespace, getNamedImportOriginal, } = trackZodSchemaImports();
+        return {
+            ImportDeclaration: importDeclarationListener,
+            CallExpression(node) {
+                const { callee } = node;
+                if (callee.type === AST_NODE_TYPES.MemberExpression &&
+                    callee.property.type === AST_NODE_TYPES.Identifier &&
+                    callee.property.name === 'describe' &&
+                    callee.object.type === AST_NODE_TYPES.Identifier &&
+                    isZodNamespace(callee.object.name)) {
+                    const [describeArg] = node.arguments;
+                    context.report({
+                        node,
+                        messageId: 'preferMeta',
+                        fix(fixer) {
+                            return [
+                                fixer.replaceText(callee.property, 'meta'),
+                                fixer.replaceText(describeArg, `{ description: ${context.sourceCode.getText(describeArg)} }`),
+                            ];
+                        },
+                    });
+                    return;
+                }
+                if (callee.type === AST_NODE_TYPES.Identifier &&
+                    getNamedImportOriginal(callee.name) === 'describe') {
+                    context.report({ node, messageId: 'preferMeta' });
+                }
+            },
+        };
+    },
+});

package/dist/src/rules/prefer-meta.spec.d.ts

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

package/dist/src/rules/prefer-meta.spec.js

@@ -0,0 +1,118 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferMeta } from './prefer-meta.js';
+const ruleTester = new RuleTester();
+ruleTester.run(preferMeta.name, preferMeta, {
+    valid: [
+        {
+            name: 'namespace import',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.string().check(z.meta({ description: "desc" }));
+      `,
+        },
+        {
+            name: 'named import',
+            code: dedent `
+        import { string, meta } from 'zod/mini';
+        string().check(meta({ description: "desc" }));
+      `,
+        },
+        {
+            name: 'named z import',
+            code: dedent `
+        import { z } from 'zod/mini';
+        z.string().check(z.meta({ description: "desc" }));
+      `,
+        },
+        {
+            name: 'no describe call',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.string().check(z.min(5));
+      `,
+        },
+        {
+            name: 'not triggered on zod import',
+            code: dedent `
+        import * as z from 'zod';
+        z.string().describe("desc");
+      `,
+        },
+        {
+            name: 'ignores non-zod describe methods',
+            code: dedent `
+        import { test } from "@playwright/test";
+        test.describe("test", () => {});
+      `,
+        },
+        {
+            name: 'zod/v4-mini import',
+            code: dedent `
+        import * as z from 'zod/v4-mini';
+        z.string().check(z.meta({ description: "desc" }));
+      `,
+        },
+    ],
+    invalid: [
+        {
+            name: 'namespace import',
+            code: dedent `
+        import * as z from 'zod/mini';
+        z.string().check(z.describe("desc"));
+      `,
+            errors: [{ messageId: 'preferMeta' }],
+            output: dedent `
+        import * as z from 'zod/mini';
+        z.string().check(z.meta({ description: "desc" }));
+      `,
+        },
+        {
+            name: 'named import',
+            code: dedent `
+        import { string, describe } from 'zod/mini';
+        string().check(describe("desc"));
+      `,
+            errors: [{ messageId: 'preferMeta' }],
+            output: null,
+        },
+        {
+            name: 'named z import',
+            code: dedent `
+        import { z } from 'zod/mini';
+        z.string().check(z.describe("desc"));
+      `,
+            errors: [{ messageId: 'preferMeta' }],
+            output: dedent `
+        import { z } from 'zod/mini';
+        z.string().check(z.meta({ description: "desc" }));
+      `,
+        },
+        {
+            name: 'zod/v4-mini import',
+            code: dedent `
+        import * as z from 'zod/v4-mini';
+        z.string().check(z.describe("desc"));
+      `,
+            errors: [{ messageId: 'preferMeta' }],
+            output: dedent `
+        import * as z from 'zod/v4-mini';
+        z.string().check(z.meta({ description: "desc" }));
+      `,
+        },
+        {
+            name: 'with template literal',
+            code: dedent `
+        import * as z from 'zod/mini';
+        const desc = 'desc';
+        z.string().check(z.describe(\`desc\${desc}\`));
+      `,
+            errors: [{ messageId: 'preferMeta' }],
+            output: dedent `
+        import * as z from 'zod/mini';
+        const desc = 'desc';
+        z.string().check(z.meta({ description: \`desc\${desc}\` }));
+      `,
+        },
+    ],
+});

package/dist/src/rules/prefer-namespace-import.d.ts

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