zodvex 0.7.1-beta.2 → 0.7.1-beta.4

package/dist/cli/codemod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codemod.d.ts","sourceRoot":"","sources":["../../src/cli/codemod.ts"],"names":[],"mappings":"AAaA,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GACjC,OAAO,CAAC,IAAI,CAAC,CA+Df"}
+{"version":3,"file":"codemod.d.ts","sourceRoot":"","sources":["../../src/cli/codemod.ts"],"names":[],"mappings":"AAyBA,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GACjC,OAAO,CAAC,IAAI,CAAC,CA6Ef"}

package/dist/cli/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
-import fs2, { readFileSync, writeFileSync } from 'fs';
-import path3, { resolve, relative } from 'path';
+import fs2, { readFileSync, writeFileSync, existsSync } from 'fs';
+import path3, { resolve, relative, join } from 'path';
 import { Project, SyntaxKind } from 'ts-morph';
 import { globSync } from 'tinyglobby';
 import { $ZodCodec, $ZodNumber, $ZodCustom, $ZodOptional, $ZodNullable, $ZodObject, $ZodUnion, $ZodArray, $ZodRecord, $ZodTuple, $ZodString, $ZodBoolean, $ZodNull, $ZodUndefined, $ZodAny, $ZodEnum, $ZodLiteral } from 'zod/v4/core';
@@ -341,6 +341,11 @@ function transformMethods(file, typeChecker) {
       count++;
       continue;
     }
+    if (method === "unwrap" && call.getArguments().length === 0) {
+      call.replaceWithText(`${obj}._zod.def.innerType`);
+      count++;
+      continue;
+    }
     if (CHECK_WRAP_METHODS.includes(method)) {
       const argsStr = args.join(", ");
       call.replaceWithText(`${obj}.check(z.${method}(${argsStr}))`);
@@ -378,6 +383,65 @@ function transformConstructorReplacements(file) {
   }
   return count;
 }
+function isZodSchemaByTypePA(pa, typeChecker) {
+  const receiver = pa.getExpression();
+  try {
+    const type = typeChecker.getTypeAtLocation(receiver);
+    if (type.isAny()) return null;
+    return type.getProperties().some((p) => p.getName() === "_zod");
+  } catch {
+    return null;
+  }
+}
+function transformPropertyAccessors(file, typeChecker) {
+  let count = 0;
+  const propAccesses = file.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression).reverse();
+  for (const pa of propAccesses) {
+    if (pa.wasForgotten()) continue;
+    const propName = pa.getName();
+    const replacement = INTERNAL_PROPERTY_ACCESSORS[propName];
+    if (!replacement) continue;
+    const receiver = pa.getExpression();
+    const receiverText = receiver.getText();
+    if (NAMESPACE_IDENTIFIERS.has(receiverText.trim())) continue;
+    if (receiverText.includes("._zod.def.") || receiverText.endsWith("._zod.def")) continue;
+    let isSchema;
+    if (typeChecker) {
+      const typeResult = isZodSchemaByTypePA(pa, typeChecker);
+      isSchema = typeResult === true || typeResult === null && isLikelySchemaExpr(receiverText);
+    } else {
+      isSchema = isLikelySchemaExpr(receiverText);
+    }
+    if (!isSchema) continue;
+    pa.replaceWithText(`${receiverText}.${replacement}`);
+    count++;
+  }
+  return count;
+}
+function findInternalPropertyAccess(file, typeChecker) {
+  const results = [];
+  const propAccesses = file.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression);
+  for (const pa of propAccesses) {
+    if (pa.wasForgotten()) continue;
+    const propName = pa.getName();
+    if (!(propName in INTERNAL_PROPERTY_ACCESSORS)) continue;
+    const receiver = pa.getExpression();
+    const receiverText = receiver.getText();
+    if (NAMESPACE_IDENTIFIERS.has(receiverText.trim())) continue;
+    if (receiverText.includes("._zod.def.") || receiverText.endsWith("._zod.def")) continue;
+    if (isLikelySchemaExpr(receiverText)) continue;
+    if (typeChecker) {
+      const typeResult = isZodSchemaByTypePA(pa, typeChecker);
+      if (typeResult === false) continue;
+    }
+    results.push({
+      line: pa.getStartLineNumber(),
+      property: propName,
+      text: pa.getText().slice(0, 80)
+    });
+  }
+  return results;
+}
 function findObjectOnlyMethods(file) {
   const results = [];
   const calls = file.getDescendantsOfKind(SyntaxKind.CallExpression);
@@ -406,7 +470,8 @@ function transformImports(file) {
 }
 function transformClassRefs(file) {
   let count = 0;
-  const neededImports = /* @__PURE__ */ new Set();
+  const runtimeImports = /* @__PURE__ */ new Set();
+  const typeOnlyImports = /* @__PURE__ */ new Set();
   const propAccesses = file.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression);
   for (const pa of propAccesses) {
     if (pa.wasForgotten()) continue;
@@ -414,33 +479,69 @@ function transformClassRefs(file) {
     const replacement = CLASS_RENAMES[text];
     if (!replacement) continue;
     pa.replaceWithText(replacement);
-    neededImports.add(replacement);
+    runtimeImports.add(replacement);
+    count++;
+  }
+  const qualNames = file.getDescendantsOfKind(SyntaxKind.QualifiedName);
+  for (const qn of qualNames) {
+    if (qn.wasForgotten()) continue;
+    const text = qn.getText();
+    const replacement = CLASS_RENAMES[text];
+    if (!replacement) continue;
+    qn.replaceWithText(replacement);
+    if (!runtimeImports.has(replacement)) {
+      typeOnlyImports.add(replacement);
+    }
     count++;
   }
-  if (neededImports.size > 0) {
+  for (const name of runtimeImports) {
+    typeOnlyImports.delete(name);
+  }
+  const addToExistingImport = (imp, names) => {
+    if (!imp) return;
+    for (const name of names) {
+      if (!imp.getNamedImports().some((n) => n.getName() === name)) {
+        imp.addNamedImport(name);
+      }
+    }
+  };
+  if (runtimeImports.size > 0) {
     const existingCoreImport = file.getImportDeclaration(
-      (d) => d.getModuleSpecifierValue() === "zod/v4/core"
+      (d) => d.getModuleSpecifierValue() === "zod/v4/core" && !d.isTypeOnly()
     );
     if (existingCoreImport) {
-      for (const name of neededImports) {
-        if (!existingCoreImport.getNamedImports().some((n) => n.getName() === name)) {
-          existingCoreImport.addNamedImport(name);
-        }
-      }
+      addToExistingImport(existingCoreImport, runtimeImports);
     } else {
       const internalImport = file.getImportDeclaration(
-        (d) => d.getModuleSpecifierValue().endsWith("/zod-core")
+        (d) => d.getModuleSpecifierValue().endsWith("/zod-core") && !d.isTypeOnly()
       );
       if (internalImport) {
-        for (const name of neededImports) {
-          if (!internalImport.getNamedImports().some((n) => n.getName() === name)) {
-            internalImport.addNamedImport(name);
-          }
-        }
+        addToExistingImport(internalImport, runtimeImports);
+      } else {
+        file.addImportDeclaration({
+          moduleSpecifier: "zod/v4/core",
+          namedImports: [...runtimeImports].sort()
+        });
+      }
+    }
+  }
+  if (typeOnlyImports.size > 0) {
+    const existingTypeImport = file.getImportDeclaration(
+      (d) => d.getModuleSpecifierValue() === "zod/v4/core" && d.isTypeOnly()
+    );
+    if (existingTypeImport) {
+      addToExistingImport(existingTypeImport, typeOnlyImports);
+    } else {
+      const internalTypeImport = file.getImportDeclaration(
+        (d) => d.getModuleSpecifierValue().endsWith("/zod-core") && d.isTypeOnly()
+      );
+      if (internalTypeImport) {
+        addToExistingImport(internalTypeImport, typeOnlyImports);
       } else {
         file.addImportDeclaration({
           moduleSpecifier: "zod/v4/core",
-          namedImports: [...neededImports].sort()
+          namedImports: [...typeOnlyImports].sort(),
+          isTypeOnly: true
         });
       }
     }
@@ -453,19 +554,23 @@ function transformFile(file, typeChecker) {
   let wrappers = 0;
   let checks = 0;
   let methods = 0;
+  let propertyAccessors = 0;
   for (let i = 0; i < 10; i++) {
     const cr = transformConstructorReplacements(file);
     const w = transformWrappers(file);
     const c = transformChecks(file);
     const m = transformMethods(file, typeChecker);
+    const pa = transformPropertyAccessors(file, typeChecker);
     constructorReplacements += cr;
     wrappers += w;
     checks += c;
     methods += m;
-    if (cr + w + c + m === 0) break;
+    propertyAccessors += pa;
+    if (cr + w + c + m + pa === 0) break;
   }
   const classRefs = transformClassRefs(file);
   const objectOnlyWarnings = findObjectOnlyMethods(file);
+  const propertyAccessWarnings = findInternalPropertyAccess(file, typeChecker);
   const imports = 0;
   return {
     filePath,
@@ -473,10 +578,12 @@ function transformFile(file, typeChecker) {
     wrappers,
     checks,
     methods,
+    propertyAccessors,
     imports,
     classRefs,
     objectOnlyWarnings,
-    totalChanges: constructorReplacements + wrappers + checks + methods + classRefs
+    propertyAccessWarnings,
+    totalChanges: constructorReplacements + wrappers + checks + methods + propertyAccessors + classRefs
   };
 }
 function transformCode(code, options) {
@@ -504,7 +611,7 @@ function transformCode(code, options) {
     return { code, changed: false };
   }
 }
-var WRAPPER_METHODS, NAMESPACE_IDENTIFIERS, ZOD_ONLY_CHECK_METHODS, AMBIGUOUS_CHECK_METHODS, STRING_RENAME, NUMBER_RENAME, UNCONDITIONAL_TOP_LEVEL, AMBIGUOUS_TOP_LEVEL, RENAMED_METHODS, TRANSFORM_METHOD, CHECK_WRAP_METHODS, CONSTRUCTOR_REPLACEMENTS, WARN_METHODS, CLASS_RENAMES;
+var WRAPPER_METHODS, NAMESPACE_IDENTIFIERS, ZOD_ONLY_CHECK_METHODS, AMBIGUOUS_CHECK_METHODS, STRING_RENAME, NUMBER_RENAME, UNCONDITIONAL_TOP_LEVEL, AMBIGUOUS_TOP_LEVEL, RENAMED_METHODS, TRANSFORM_METHOD, CHECK_WRAP_METHODS, CONSTRUCTOR_REPLACEMENTS, INTERNAL_PROPERTY_ACCESSORS, WARN_METHODS, CLASS_RENAMES;
 var init_transforms = __esm({
   "../zod-to-mini/src/transforms.ts"() {
     WRAPPER_METHODS = ["optional", "nullable"];
@@ -550,7 +657,7 @@ var init_transforms = __esm({
       min: "gte",
       max: "lte"
     };
-    UNCONDITIONAL_TOP_LEVEL = ["pipe", "brand"];
+    UNCONDITIONAL_TOP_LEVEL = ["pipe", "brand", "parse", "safeParse"];
     AMBIGUOUS_TOP_LEVEL = ["partial", "extend", "catchall", "omit", "pick"];
     RENAMED_METHODS = /* @__PURE__ */ new Map([
       ["default", "_default"]
@@ -561,6 +668,11 @@ var init_transforms = __esm({
       passthrough: "looseObject",
       strict: "strictObject"
     };
+    INTERNAL_PROPERTY_ACCESSORS = {
+      shape: "_zod.def.shape",
+      element: "_zod.def.element",
+      options: "_zod.def.options"
+    };
     WARN_METHODS = [
       "merge"
       // use z.extend() or spread
@@ -569,6 +681,7 @@ var init_transforms = __esm({
       "z.ZodError": "$ZodError",
       "z.ZodType": "$ZodType",
       "z.ZodTypeAny": "$ZodType",
+      "z.ZodRawShape": "$ZodShape",
       "z.ZodObject": "$ZodObject",
       "z.ZodArray": "$ZodArray",
       "z.ZodString": "$ZodString",
@@ -583,7 +696,12 @@ var init_transforms = __esm({
       "z.ZodCustom": "$ZodCustom",
       "z.ZodDefault": "$ZodDefault",
       "z.ZodRecord": "$ZodRecord",
-      "z.ZodTuple": "$ZodTuple"
+      "z.ZodTuple": "$ZodTuple",
+      "z.ZodDiscriminatedUnion": "$ZodDiscriminatedUnion",
+      "z.ZodLazy": "$ZodLazy",
+      "z.ZodPipe": "$ZodPipe",
+      "z.ZodTransform": "$ZodTransform",
+      "z.ZodReadonly": "$ZodReadonly"
     };
   }
 });
@@ -646,6 +764,16 @@ var codemod_exports = {};
 __export(codemod_exports, {
   runToMiniCodemod: () => runToMiniCodemod
 });
+function findTsconfig(startDir) {
+  let dir = startDir;
+  while (true) {
+    const candidate = join(dir, "tsconfig.json");
+    if (existsSync(candidate)) return candidate;
+    const parent = resolve(dir, "..");
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
 async function runToMiniCodemod(targetDir, options = {}) {
   const { transformCode: transformCode2, transformImports: transformImports2 } = await Promise.resolve().then(() => (init_src(), src_exports));
   const { Project: Project3 } = await import('ts-morph');
@@ -655,6 +783,15 @@ async function runToMiniCodemod(targetDir, options = {}) {
     ignore: ["_generated/**", "_zodvex/**", "**/*.d.ts", "node_modules/**"],
     absolute: true
   });
+  let typeProject;
+  const tsconfigPath = findTsconfig(dir);
+  if (tsconfigPath) {
+    typeProject = new Project3({
+      tsConfigFilePath: tsconfigPath,
+      skipAddingFilesFromTsConfig: true
+    });
+    console.log(`[zodvex codemod] Using type checker (${relative(process.cwd(), tsconfigPath)})`);
+  }
   console.log(
     `[zodvex codemod] ${options.dryRun ? "Dry run \u2014 " : ""}Processing ${files.length} files in ${targetDir}/`
   );
@@ -663,7 +800,10 @@ async function runToMiniCodemod(targetDir, options = {}) {
   for (const filePath of files) {
     const code = readFileSync(filePath, "utf-8");
     if (!code.includes("'zod'") && !code.includes('"zod"')) continue;
-    const result = transformCode2(code);
+    const result = transformCode2(code, {
+      filename: filePath,
+      project: typeProject
+    });
     let output = result.code;
     const project = new Project3({ useInMemoryFileSystem: true });
     const sf = project.createSourceFile("tmp.ts", output);
@@ -1591,8 +1731,8 @@ Usage:
   zodvex init                            Set up zodvex in an existing Convex project
   zodvex migrate [dir]                   Migrate pre-0.6 APIs (renames + import fixes)
   zodvex migrate [dir] --dry-run         Preview changes without writing
-  zodvex codemod --to-mini [dir]         Convert full-zod code to zod/mini syntax
-  zodvex codemod --to-mini [dir] --dry-run  Preview changes without writing
+  zodvex codemod --to-mini [dir]           Convert full-zod code to zod/mini syntax
+  zodvex codemod --to-mini [dir] --dry-run Preview changes without writing
   zodvex help                            Show this help message
 
 Flags: