Ban default imports (#10)

samchungy · web-flow · commit 01acb1c85f81 · 2025-07-29T14:22:05.000+10:00
* Ban default imports

* add changeset
diff --git a/.changeset/happy-papers-accept.md b/.changeset/happy-papers-accept.md
@@ -0,0 +1,15 @@
+---
+"eslint-plugin-import-zod": minor
+---
+
+Default imports are now converted to namespace imports
+
+```ts
+import z from "zod";
+```
+
+to
+
+```ts
+import * as z from "zod";
+```
diff --git a/README.md b/README.md
@@ -3,7 +3,7 @@
 <a href="https://www.npmjs.com/package/eslint-plugin-import-zod"><img src="https://img.shields.io/npm/v/eslint-plugin-import-zod"/></a>
 <a href="https://nodejs.org/en/"><img src="https://img.shields.io/node/v/eslint-plugin-import-zod"/></a>
 
-ESLint plugin to enforce namespace imports for zod. This plugin provides a rule that ensures all imports of zod use the namespace import style (`import * as z from "zod";`) instead of named imports to promote better tree-shaking and reduce bundle sizes. See [this Zod issue comment](https://github.com/colinhacks/zod/issues/4433#issuecomment-2921500831) for a more detailed explanation.
+ESLint plugin to enforce namespace imports for zod. This plugin provides a rule that ensures all imports of zod use the namespace import style (`import * as z from "zod";`) instead of named imports or default imports to promote better tree-shaking and reduce bundle sizes. See [this Zod issue comment](https://github.com/colinhacks/zod/issues/4433#issuecomment-2921500831) for a more detailed explanation.
 
 ## Installation
 
@@ -37,16 +37,30 @@ export default [
 
 ### [`prefer-zod-namespace`](docs/rules/prefer-zod-namespace.md)
 
-This rule enforces using namespace imports for zod instead of named imports.
+This rule enforces using namespace imports for zod instead of named imports or default imports.
 
 #### ❌ Invalid
 
 ```js
 // Importing z directly
 import { z } from "zod";
 
+// Default imports (any name)
+import z from "zod";
+import zod from "zod";
+import zodSchema from "zod";
+
+// Type default imports
+import type z from "zod";
+import type zod from "zod";
+
+// Mixed default and named imports
+import z, { toJSONSchema } from "zod";
+import zod, { ZodError } from "zod";
+
 // Importing z from 'zod/v4'
 import { z } from "zod/v4";
+import z from "zod/v4";
 
 // Importing z from 'zod/v4-mini'
 import { z } from "zod/v4-mini";
@@ -73,6 +87,10 @@ import { core } from "zod/v4";
 // Using namespace import
 import * as z from "zod";
 
+// Using namespace import with any name
+import * as zod from "zod";
+import * as zodSchema from "zod";
+
 // Importing z from 'zod/v4'
 import * as z from "zod/v4";
 
@@ -81,6 +99,7 @@ import * as z from "zod/v4-mini";
 
 // Using type namespace import
 import type * as z from "zod";
+import type * as zod from "zod";
 
 // Other imports from zod that don't include 'z'
 import { ZodError } from "zod";
@@ -97,13 +116,21 @@ import * as core from "zod/v4/core";
 This rule is automatically fixable. When using `--fix`, ESLint will:
 
 - Convert `import { z } from 'zod';` to `import * as z from 'zod';`
+- Convert `import z from 'zod';` to `import * as z from 'zod';`
+- Convert `import zod from 'zod';` to `import * as zod from 'zod';`
+- Convert `import type z from 'zod';` to `import type * as z from 'zod';`
 - Convert `import type { z } from 'zod';` to `import type * as z from 'zod';`
 - Convert `import { core } from 'zod/v4';` to `import * as core from 'zod/v4/core';`
 - Split mixed imports like `import { ZodError, z } from 'zod';` into:
   ```js
   import * as z from "zod";
   import { ZodError } from "zod";
   ```
+- Split default and named imports like `import z, { toJSONSchema } from 'zod';` into:
+  ```js
+  import * as z from "zod";
+  import { toJSONSchema } from "zod";
+  ```
 - Split type imports like `import type { ZodError, z } from 'zod';` into:
   ```js
   import type * as z from "zod";
diff --git a/docs/rules/prefer-zod-namespace.md b/docs/rules/prefer-zod-namespace.md
@@ -1,6 +1,6 @@
 # Enforce namespace imports for zod (prefer-zod-namespace)
 
-This rule enforces using namespace imports for zod instead of named imports. Using namespace imports results in better tree-shaking and reduced bundle sizes.
+This rule enforces using namespace imports for zod instead of named imports or default imports. Using namespace imports results in better tree-shaking and reduced bundle sizes. All default imports from 'zod' are converted to namespace imports regardless of the import name.
 
 ## Rule Details
 
@@ -12,6 +12,19 @@ This rule aims to enforce a consistent pattern for importing zod.
 // Importing z directly
 import { z } from "zod";
 
+// Default import
+import z from "zod";
+
+// Type default import
+import type z from "zod";
+
+// Mixed default and named imports
+import z, { toJSONSchema } from "zod";
+
+// Default imports with any name
+import zod from "zod";
+import zodSchema from "zod";
+
 // Type imports
 import type { z } from "zod";
 
diff --git a/src/rules/prefer-zod-namespace.ts b/src/rules/prefer-zod-namespace.ts
@@ -37,7 +37,7 @@ export default createRule({
     schema: [], // No options
     messages: {
       preferNamespaceImport:
-        'Import zod as a namespace (import * as z from "zod") instead of destructuring its exports',
+        'Import zod as a namespace (import * as z from "zod") instead of destructuring its exports or using default imports',
     },
   },
 
@@ -61,12 +61,18 @@ export default createRule({
             specifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier
         );
 
-        // If there are no named imports, there's nothing to check
-        if (namedSpecifiers.length === 0) {
+        // Check if it's a default import (e.g., import z from 'zod')
+        const defaultSpecifiers = node.specifiers.filter(
+          (specifier) =>
+            specifier.type === TSESTree.AST_NODE_TYPES.ImportDefaultSpecifier
+        );
+
+        // If there are no named or default imports, there's nothing to check
+        if (namedSpecifiers.length === 0 && defaultSpecifiers.length === 0) {
           return;
         }
 
-        // Find 'z' or 'core' imports specifically
+        // Find 'z' or 'core' imports specifically in named imports
         const zodSpecifiers = namedSpecifiers.filter(
           (
             specifier: TSESTree.ImportSpecifier
@@ -78,12 +84,101 @@ export default createRule({
               specifier.imported.name === "core")
         );
 
-        // If there's no 'z' or 'core' import, we don't need to do anything
-        if (zodSpecifiers.length === 0) {
+        // Find all default imports (any name)
+        const zodDefaultSpecifiers = defaultSpecifiers;
+
+        // If there's no 'z' or 'core' named import and no default imports, we don't need to do anything
+        if (zodSpecifiers.length === 0 && zodDefaultSpecifiers.length === 0) {
           return;
         }
 
-        // Handle each zod specifier
+        // Handle each zod default specifier
+        for (const zodDefaultSpecifier of zodDefaultSpecifiers) {
+          const localName = zodDefaultSpecifier.local.name;
+          const importSource = node.source.value;
+
+          // Report the issue for default import
+          context.report({
+            node: zodDefaultSpecifier,
+            messageId: "preferNamespaceImport",
+            fix(fixer) {
+              // If this is the only specifier
+              if (node.specifiers.length === 1) {
+                // Simple case: just replace with a namespace import
+                const isTypeOnlyImport = node.importKind === "type";
+                const typePrefix = isTypeOnlyImport ? "type " : "";
+                return fixer.replaceText(
+                  node,
+                  `import ${typePrefix}* as ${localName} from '${importSource}';`
+                );
+              } else {
+                // Handle the case where we need to split imports
+                const otherSpecifiers = node.specifiers.filter(
+                  (s) => s !== zodDefaultSpecifier
+                );
+
+                // Check if this is a type-only import
+                const isTypeOnlyImport = node.importKind === "type";
+
+                // Create a namespace import for the zod default specifier
+                const typePrefix = isTypeOnlyImport ? "type " : "";
+                const namespaceImport = `import ${typePrefix}* as ${localName} from '${importSource}';\n`;
+
+                // Create a new import for the other specifiers
+                const otherImportParts: string[] = [];
+
+                // Handle other default imports
+                const otherDefaultSpecifiers = otherSpecifiers.filter(
+                  (s) =>
+                    s.type === TSESTree.AST_NODE_TYPES.ImportDefaultSpecifier
+                );
+
+                // Handle other named imports
+                const otherNamedSpecifiers = otherSpecifiers.filter(
+                  (s) => s.type === TSESTree.AST_NODE_TYPES.ImportSpecifier
+                );
+
+                if (otherDefaultSpecifiers.length > 0) {
+                  const defaultName = otherDefaultSpecifiers[0].local.name;
+                  otherImportParts.push(defaultName);
+                }
+
+                if (otherNamedSpecifiers.length > 0) {
+                  const namedPart = `{ ${otherNamedSpecifiers
+                    .map((s) => {
+                      const specifierLocalName = s.local.name;
+                      const specifierImportedName =
+                        s.imported.type === TSESTree.AST_NODE_TYPES.Identifier
+                          ? s.imported.name
+                          : "";
+                      // Preserve individual type imports when not a type-only import
+                      const typeModifier =
+                        !isTypeOnlyImport && s.importKind === "type"
+                          ? "type "
+                          : "";
+                      return specifierLocalName === specifierImportedName
+                        ? `${typeModifier}${specifierImportedName}`
+                        : `${typeModifier}${specifierImportedName} as ${specifierLocalName}`;
+                    })
+                    .join(", ")} }`;
+                  otherImportParts.push(namedPart);
+                }
+
+                const otherImport = `import ${
+                  isTypeOnlyImport ? "type " : ""
+                }${otherImportParts.join(", ")} from '${importSource}';`;
+
+                // Replace the entire import declaration
+                return fixer.replaceText(
+                  node,
+                  `${namespaceImport}${otherImport}`
+                );
+              }
+            },
+          });
+        }
+
+        // Handle each zod named specifier (existing logic)
         for (const zodSpecifier of zodSpecifiers) {
           // Get the local name of the import (in case it's renamed)
           const localName = zodSpecifier.local.name;
diff --git a/tests/prefer-zod-namespace.test.ts b/tests/prefer-zod-namespace.test.ts
@@ -30,8 +30,7 @@ ruleTester.run("prefer-zod-namespace-import", rule, {
     "import { toJSONSchema } from 'zod';",
     // Other type imports from zod that don't include 'z' are valid
     "import type { toJSONSchema } from 'zod';",
-    // Default import would be valid (though zod doesn't have one)
-    "import zod from 'zod';",
+
     // Imports from other modules are valid
     "import { z } from 'not-zod';",
   ],
@@ -58,6 +57,66 @@ ruleTester.run("prefer-zod-namespace-import", rule, {
       output: "import * as z from 'zod/v3';",
       errors: [{ messageId: "preferNamespaceImport" }],
     },
+    // Default import cases
+    {
+      code: "import z from 'zod';",
+      output: "import * as z from 'zod';",
+      errors: [{ messageId: "preferNamespaceImport" }],
+    },
+    {
+      code: "import z from 'zod/v4';",
+      output: "import * as z from 'zod/v4';",
+      errors: [{ messageId: "preferNamespaceImport" }],
+    },
+    {
+      code: "import z from 'zod/v3';",
+      output: "import * as z from 'zod/v3';",
+      errors: [{ messageId: "preferNamespaceImport" }],
+    },
+    {
+      code: "import type z from 'zod';",
+      output: "import type * as z from 'zod';",
+      errors: [{ messageId: "preferNamespaceImport" }],
+    },
+    // Mixed default and named imports
+    {
+      code: "import z, { toJSONSchema } from 'zod';",
+      output: "import * as z from 'zod';\nimport { toJSONSchema } from 'zod';",
+      errors: [{ messageId: "preferNamespaceImport" }],
+    },
+    {
+      code: "import type z, { toJSONSchema } from 'zod';",
+      output:
+        "import type * as z from 'zod';\nimport type { toJSONSchema } from 'zod';",
+      errors: [{ messageId: "preferNamespaceImport" }],
+    },
+    // Default imports with any name should be converted
+    {
+      code: "import zod from 'zod';",
+      output: "import * as zod from 'zod';",
+      errors: [{ messageId: "preferNamespaceImport" }],
+    },
+    {
+      code: "import zodSchema from 'zod';",
+      output: "import * as zodSchema from 'zod';",
+      errors: [{ messageId: "preferNamespaceImport" }],
+    },
+    {
+      code: "import Z from 'zod';",
+      output: "import * as Z from 'zod';",
+      errors: [{ messageId: "preferNamespaceImport" }],
+    },
+    {
+      code: "import type zod from 'zod';",
+      output: "import type * as zod from 'zod';",
+      errors: [{ messageId: "preferNamespaceImport" }],
+    },
+    {
+      code: "import zod, { toJSONSchema } from 'zod';",
+      output:
+        "import * as zod from 'zod';\nimport { toJSONSchema } from 'zod';",
+      errors: [{ messageId: "preferNamespaceImport" }],
+    },
     // Submodule imports from zod/v4
     {
       code: "import { core } from 'zod/v4';",
