zod-v3-to-v4 1.7.1 → 1.8.0

package/dist/migrate.js

@@ -3,6 +3,7 @@ import { findRootExpression } from "./ast.js";
 import { collectZodImportDeclarations, collectZodReferences, getZodName, } from "./collect-imports.js";
 import { convertZArrayPatternsToTopLevelApi, convertZCoercePatternsToTopLevelApi, convertZFunctionPatternsToTopLevelApi, convertZNumberPatternsToZInt, convertZObjectPatternsToTopLevelApi, convertZRecordPatternsToTopLevelApi, convertZStringPatternsToTopLevelApi, } from "./convert-name-to-top-level-api.js";
 import { convertDeprecatedErrorKeysToErrorFunction, convertErrorMapToErrorFunction, convertMessageKeyToError, convertZodErrorAddIssueToDirectPushes, convertZodErrorToTreeifyError, } from "./convert-zod-errors.js";
+import { replaceDeletedTypes } from "./replace-deleted-types.js";
 import { isZodNode } from "./zod-node.js";
 export function migrateZodV3ToV4(sourceFile, options = {}) {
     const importDeclarations = collectZodImportDeclarations(sourceFile);
@@ -17,7 +18,10 @@ export function migrateZodV3ToV4(sourceFile, options = {}) {
             declaration.setModuleSpecifier("zod/v4");
         }
     });
-    collectZodReferences(importDeclarations).forEach((node) => {
+    // Collect references before modifying imports
+    const zodReferences = collectZodReferences(importDeclarations);
+    replaceDeletedTypes(importDeclarations, zodReferences);
+    zodReferences.forEach((node) => {
         if (node.wasForgotten()) {
             return;
         }

package/dist/replace-deleted-types.js

@@ -0,0 +1,75 @@
+import { SyntaxKind } from "ts-morph";
+const DELETED_TYPES = [
+    {
+        name: "AnyZodObject",
+        importName: "ZodRecord",
+        getReplacement: () => "ZodRecord<any, any>",
+    },
+    {
+        name: "SafeParseReturnType",
+        importName: "ZodSafeParseResult",
+        getReplacement: (node) => {
+            // SafeParseReturnType<I, O> -> ZodSafeParseResult<O>
+            // Keep only the second type argument for consistency
+            // See https://github.com/colinhacks/zod/issues/5195
+            const typeRef = node.getFirstAncestorByKind(SyntaxKind.TypeReference);
+            const secondArg = typeRef?.getTypeArguments()?.[1];
+            return secondArg
+                ? `ZodSafeParseResult<${secondArg.getText()}>`
+                : "ZodSafeParseResult<unknown>";
+        },
+    },
+    {
+        name: "ZodTypeAny",
+        importName: "ZodType",
+        getReplacement: () => "ZodType",
+    },
+];
+export function replaceDeletedTypes(importDeclarations, zodReferences) {
+    // Update imports: remove deleted types and add replacements
+    importDeclarations.forEach((declaration) => {
+        for (const { name, importName } of DELETED_TYPES) {
+            const namedImports = declaration.getNamedImports();
+            const deletedImport = namedImports.find((i) => i.getName() === name);
+            if (deletedImport) {
+                const hasReplacementImport = namedImports.some((i) => i.getName() === importName);
+                deletedImport.remove();
+                if (!hasReplacementImport) {
+                    declaration.addNamedImport(importName);
+                }
+            }
+        }
+    });
+    // Replace references in code
+    zodReferences.forEach((node) => {
+        if (node.wasForgotten()) {
+            return;
+        }
+        for (const { name, importName, getReplacement } of DELETED_TYPES) {
+            // Handle direct imports (e.g., `import { AnyZodObject }`)
+            if (node.getText() === name) {
+                const typeRef = node.getFirstAncestorByKind(SyntaxKind.TypeReference);
+                if (typeRef) {
+                    typeRef.replaceWithText(getReplacement(node));
+                }
+                else {
+                    node.replaceWithText(getReplacement(node));
+                }
+                return;
+            }
+            // Handle prefixed access (e.g., `z.AnyZodObject`)
+            const qualifiedName = node.getFirstAncestorByKind(SyntaxKind.QualifiedName);
+            if (qualifiedName?.getText().endsWith(`.${name}`)) {
+                const typeRef = qualifiedName.getFirstAncestorByKind(SyntaxKind.TypeReference);
+                const zodPrefix = node.getText();
+                if (typeRef) {
+                    typeRef.replaceWithText(`${zodPrefix}.${getReplacement(node)}`);
+                }
+                else {
+                    qualifiedName.replaceWithText(`${zodPrefix}.${importName}`);
+                }
+                return;
+            }
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod-v3-to-v4",
-  "version": "1.7.1",
+  "version": "1.8.0",
   "description": "Migrate Zod from v3 to v4",
   "keywords": [
     "zod",