zodvex 0.7.1-beta.1 → 0.7.1-beta.3

package/dist/cli/codemod.d.ts

@@ -0,0 +1,4 @@
+export declare function runToMiniCodemod(targetDir: string, options?: {
+    dryRun?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=codemod.d.ts.map

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

@@ -0,0 +1 @@
+{"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,7 @@
 #!/usr/bin/env bun
-import fs2 from 'fs';
-import path3 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';
 
@@ -217,6 +218,525 @@ var init_migrate = __esm({
     ];
   }
 });
+function getCallObject(call) {
+  const expr = call.getExpression();
+  if (expr.getKind() !== SyntaxKind.PropertyAccessExpression) return null;
+  const propAccess = expr;
+  return propAccess.getExpression().getText();
+}
+function getMethodName(call) {
+  const expr = call.getExpression();
+  if (expr.getKind() !== SyntaxKind.PropertyAccessExpression) return null;
+  return expr.getName();
+}
+function transformWrappers(file) {
+  let count = 0;
+  const calls = file.getDescendantsOfKind(SyntaxKind.CallExpression).reverse();
+  for (const call of calls) {
+    if (call.wasForgotten()) continue;
+    const method = getMethodName(call);
+    if (!method || !WRAPPER_METHODS.includes(method)) continue;
+    if (call.getArguments().length > 0) continue;
+    const obj = getCallObject(call);
+    if (!obj) continue;
+    call.replaceWithText(`z.${method}(${obj})`);
+    count++;
+  }
+  return count;
+}
+function isNamespaceCall(obj) {
+  return NAMESPACE_IDENTIFIERS.has(obj.trim());
+}
+function isLikelySchemaExpr(obj) {
+  if (obj.match(/^z\.\w+\(/)) return true;
+  if (obj.match(/^zx\.\w+\(/)) return true;
+  if (obj.match(/^z\.(optional|nullable)\(/)) return true;
+  return false;
+}
+function isZodSchemaByType(call, typeChecker) {
+  const expr = call.getExpression();
+  if (expr.getKind() !== SyntaxKind.PropertyAccessExpression) return false;
+  const receiver = expr.getExpression();
+  try {
+    const type = typeChecker.getTypeAtLocation(receiver);
+    if (type.isAny()) return null;
+    return type.getProperties().some((p) => p.getName() === "_zod");
+  } catch {
+    return null;
+  }
+}
+function transformChecks(file) {
+  let count = 0;
+  const calls = file.getDescendantsOfKind(SyntaxKind.CallExpression).reverse();
+  for (const call of calls) {
+    if (call.wasForgotten()) continue;
+    const method = getMethodName(call);
+    if (!method) continue;
+    const obj = getCallObject(call);
+    if (!obj) continue;
+    if (isNamespaceCall(obj)) continue;
+    const args = call.getArguments().map((a) => a.getText());
+    const argsStr = args.length > 0 ? args.join(", ") : "";
+    if (ZOD_ONLY_CHECK_METHODS.includes(method)) {
+      call.replaceWithText(`${obj}.check(z.${method}(${argsStr}))`);
+      count++;
+      continue;
+    }
+    if (AMBIGUOUS_CHECK_METHODS.includes(method) && isLikelySchemaExpr(obj)) {
+      call.replaceWithText(`${obj}.check(z.${method}(${argsStr}))`);
+      count++;
+      continue;
+    }
+    if ((method === "min" || method === "max") && isLikelySchemaExpr(obj)) {
+      const isString = obj.includes("z.string");
+      const checkName = isString ? STRING_RENAME[method] : NUMBER_RENAME[method];
+      call.replaceWithText(`${obj}.check(z.${checkName}(${argsStr}))`);
+      count++;
+      continue;
+    }
+  }
+  return count;
+}
+function transformMethods(file, typeChecker) {
+  let count = 0;
+  const calls = file.getDescendantsOfKind(SyntaxKind.CallExpression).reverse();
+  for (const call of calls) {
+    if (call.wasForgotten()) continue;
+    const method = getMethodName(call);
+    if (!method) continue;
+    const obj = getCallObject(call);
+    if (!obj) continue;
+    if (isNamespaceCall(obj)) continue;
+    const args = call.getArguments().map((a) => a.getText());
+    if (UNCONDITIONAL_TOP_LEVEL.includes(method)) {
+      const argsStr = args.length > 0 ? `, ${args.join(", ")}` : "";
+      call.replaceWithText(`z.${method}(${obj}${argsStr})`);
+      count++;
+      continue;
+    }
+    if (AMBIGUOUS_TOP_LEVEL.includes(method)) {
+      let isSchema;
+      if (typeChecker) {
+        const typeResult = isZodSchemaByType(call, typeChecker);
+        isSchema = typeResult === true || typeResult === null && isLikelySchemaExpr(obj);
+      } else {
+        isSchema = isLikelySchemaExpr(obj);
+      }
+      if (!isSchema) continue;
+      const argsStr = args.length > 0 ? `, ${args.join(", ")}` : "";
+      call.replaceWithText(`z.${method}(${obj}${argsStr})`);
+      count++;
+      continue;
+    }
+    if (RENAMED_METHODS.has(method)) {
+      const newName = RENAMED_METHODS.get(method);
+      const argsStr = args.length > 0 ? `, ${args.join(", ")}` : "";
+      call.replaceWithText(`z.${newName}(${obj}${argsStr})`);
+      count++;
+      continue;
+    }
+    if (method === TRANSFORM_METHOD) {
+      const argsStr = args.join(", ");
+      call.replaceWithText(`z.pipe(${obj}, z.transform(${argsStr}))`);
+      count++;
+      continue;
+    }
+    if (CHECK_WRAP_METHODS.includes(method)) {
+      const argsStr = args.join(", ");
+      call.replaceWithText(`${obj}.check(z.${method}(${argsStr}))`);
+      count++;
+      continue;
+    }
+  }
+  return count;
+}
+function transformConstructorReplacements(file) {
+  let count = 0;
+  const calls = file.getDescendantsOfKind(SyntaxKind.CallExpression).reverse();
+  for (const call of calls) {
+    if (call.wasForgotten()) continue;
+    const method = getMethodName(call);
+    if (!method) continue;
+    const obj = getCallObject(call);
+    if (!obj) continue;
+    if (method in CONSTRUCTOR_REPLACEMENTS && call.getArguments().length === 0) {
+      const match = obj.match(/^z\s*\.object\(([\s\S]*)\)$/);
+      if (!match) continue;
+      const shape = match[1];
+      const replacement = CONSTRUCTOR_REPLACEMENTS[method];
+      call.replaceWithText(`z.${replacement}(${shape})`);
+      count++;
+      continue;
+    }
+    if (method === "datetime" && /^z\s*\.string\(\s*\)$/.test(obj)) {
+      const args = call.getArguments().map((a) => a.getText());
+      const argsStr = args.length > 0 ? args.join(", ") : "";
+      call.replaceWithText(`z.iso.datetime(${argsStr})`);
+      count++;
+      continue;
+    }
+  }
+  return count;
+}
+function findObjectOnlyMethods(file) {
+  const results = [];
+  const calls = file.getDescendantsOfKind(SyntaxKind.CallExpression);
+  for (const call of calls) {
+    const method = getMethodName(call);
+    if (!method || !WARN_METHODS.includes(method)) continue;
+    results.push({
+      line: call.getStartLineNumber(),
+      method,
+      text: call.getText().slice(0, 80)
+    });
+  }
+  return results;
+}
+function transformImports(file) {
+  let count = 0;
+  const imports = file.getImportDeclarations();
+  for (const imp of imports) {
+    const moduleSpecifier = imp.getModuleSpecifierValue();
+    if (moduleSpecifier === "zod") {
+      imp.setModuleSpecifier("zod/mini");
+      count++;
+    }
+  }
+  return count;
+}
+function transformClassRefs(file) {
+  let count = 0;
+  const neededImports = /* @__PURE__ */ new Set();
+  const propAccesses = file.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression);
+  for (const pa of propAccesses) {
+    if (pa.wasForgotten()) continue;
+    const text = pa.getText();
+    const replacement = CLASS_RENAMES[text];
+    if (!replacement) continue;
+    pa.replaceWithText(replacement);
+    neededImports.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);
+    neededImports.add(replacement);
+    count++;
+  }
+  if (neededImports.size > 0) {
+    const existingCoreImport = file.getImportDeclaration(
+      (d) => d.getModuleSpecifierValue() === "zod/v4/core"
+    );
+    if (existingCoreImport) {
+      for (const name of neededImports) {
+        if (!existingCoreImport.getNamedImports().some((n) => n.getName() === name)) {
+          existingCoreImport.addNamedImport(name);
+        }
+      }
+    } else {
+      const internalImport = file.getImportDeclaration(
+        (d) => d.getModuleSpecifierValue().endsWith("/zod-core")
+      );
+      if (internalImport) {
+        for (const name of neededImports) {
+          if (!internalImport.getNamedImports().some((n) => n.getName() === name)) {
+            internalImport.addNamedImport(name);
+          }
+        }
+      } else {
+        file.addImportDeclaration({
+          moduleSpecifier: "zod/v4/core",
+          namedImports: [...neededImports].sort()
+        });
+      }
+    }
+  }
+  return count;
+}
+function transformFile(file, typeChecker) {
+  const filePath = file.getFilePath();
+  let constructorReplacements = 0;
+  let wrappers = 0;
+  let checks = 0;
+  let methods = 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);
+    constructorReplacements += cr;
+    wrappers += w;
+    checks += c;
+    methods += m;
+    if (cr + w + c + m === 0) break;
+  }
+  const classRefs = transformClassRefs(file);
+  const objectOnlyWarnings = findObjectOnlyMethods(file);
+  const imports = 0;
+  return {
+    filePath,
+    constructorReplacements,
+    wrappers,
+    checks,
+    methods,
+    imports,
+    classRefs,
+    objectOnlyWarnings,
+    totalChanges: constructorReplacements + wrappers + checks + methods + classRefs
+  };
+}
+function transformCode(code, options) {
+  try {
+    const project = options?.project ?? new Project({
+      useInMemoryFileSystem: true,
+      compilerOptions: { strict: false }
+    });
+    const filename = options?.filename ?? "transform.ts";
+    const file = project.createSourceFile(filename, code, { overwrite: true });
+    const typeChecker = options?.project ? project.getTypeChecker() : void 0;
+    const result = transformFile(file, typeChecker);
+    const transformed = file.getFullText();
+    if (options?.project) {
+      project.removeSourceFile(file);
+    }
+    return {
+      code: transformed,
+      changed: result.totalChanges > 0
+    };
+  } catch (err) {
+    const filename = options?.filename ?? "unknown";
+    const message = err instanceof Error ? err.message : String(err);
+    console.warn(`[zod-to-mini] Transform failed for ${filename}, returning original code: ${message}`);
+    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 init_transforms = __esm({
+  "../zod-to-mini/src/transforms.ts"() {
+    WRAPPER_METHODS = ["optional", "nullable"];
+    NAMESPACE_IDENTIFIERS = /* @__PURE__ */ new Set(["z", "zx", "zm", "zod"]);
+    ZOD_ONLY_CHECK_METHODS = [
+      "email",
+      "url",
+      "uuid",
+      "cuid",
+      "cuid2",
+      "ulid",
+      "nanoid",
+      "emoji",
+      "base64",
+      "base64url",
+      "jwt",
+      "int",
+      "positive",
+      "negative",
+      "nonnegative",
+      "nonpositive",
+      "multipleOf"
+    ];
+    AMBIGUOUS_CHECK_METHODS = [
+      "trim",
+      "toLowerCase",
+      "toUpperCase",
+      "startsWith",
+      "endsWith",
+      "includes",
+      "regex",
+      "length",
+      "gt",
+      "gte",
+      "lt",
+      "lte"
+    ];
+    STRING_RENAME = {
+      min: "minLength",
+      max: "maxLength"
+    };
+    NUMBER_RENAME = {
+      min: "gte",
+      max: "lte"
+    };
+    UNCONDITIONAL_TOP_LEVEL = ["pipe", "brand"];
+    AMBIGUOUS_TOP_LEVEL = ["partial", "extend", "catchall", "omit", "pick"];
+    RENAMED_METHODS = /* @__PURE__ */ new Map([
+      ["default", "_default"]
+    ]);
+    TRANSFORM_METHOD = "transform";
+    CHECK_WRAP_METHODS = ["refine", "superRefine", "describe"];
+    CONSTRUCTOR_REPLACEMENTS = {
+      passthrough: "looseObject",
+      strict: "strictObject"
+    };
+    WARN_METHODS = [
+      "merge"
+      // use z.extend() or spread
+    ];
+    CLASS_RENAMES = {
+      "z.ZodError": "$ZodError",
+      "z.ZodType": "$ZodType",
+      "z.ZodTypeAny": "$ZodType",
+      "z.ZodRawShape": "$ZodShape",
+      "z.ZodObject": "$ZodObject",
+      "z.ZodArray": "$ZodArray",
+      "z.ZodString": "$ZodString",
+      "z.ZodNumber": "$ZodNumber",
+      "z.ZodBoolean": "$ZodBoolean",
+      "z.ZodOptional": "$ZodOptional",
+      "z.ZodNullable": "$ZodNullable",
+      "z.ZodUnion": "$ZodUnion",
+      "z.ZodEnum": "$ZodEnum",
+      "z.ZodLiteral": "$ZodLiteral",
+      "z.ZodCodec": "$ZodCodec",
+      "z.ZodCustom": "$ZodCustom",
+      "z.ZodDefault": "$ZodDefault",
+      "z.ZodRecord": "$ZodRecord",
+      "z.ZodTuple": "$ZodTuple",
+      "z.ZodDiscriminatedUnion": "$ZodDiscriminatedUnion",
+      "z.ZodLazy": "$ZodLazy",
+      "z.ZodPipe": "$ZodPipe",
+      "z.ZodTransform": "$ZodTransform"
+    };
+  }
+});
+function zodToMiniPlugin(options) {
+  let project;
+  return {
+    name: "zod-to-mini",
+    enforce: "pre",
+    buildStart() {
+      if (options?.tsconfig) {
+        project = new Project({
+          tsConfigFilePath: options.tsconfig,
+          skipAddingFilesFromTsConfig: true
+        });
+      }
+    },
+    transform(code, id) {
+      if (!/\.[jt]sx?$/.test(id)) return;
+      if (options?.include && !options.include.test(id)) return;
+      if (options?.exclude && options.exclude.test(id)) return;
+      if (!code.includes("'zod'") && !code.includes('"zod"') && !code.includes("z.Zod")) return;
+      const result = transformCode(code, {
+        filename: id,
+        project
+      });
+      if (!result.changed) return;
+      return { code: result.code, map: null };
+    }
+  };
+}
+var init_vite_plugin = __esm({
+  "../zod-to-mini/src/vite-plugin.ts"() {
+    init_transforms();
+  }
+});
+
+// ../zod-to-mini/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  findObjectOnlyMethods: () => findObjectOnlyMethods,
+  transformChecks: () => transformChecks,
+  transformClassRefs: () => transformClassRefs,
+  transformCode: () => transformCode,
+  transformConstructorReplacements: () => transformConstructorReplacements,
+  transformFile: () => transformFile,
+  transformImports: () => transformImports,
+  transformMethods: () => transformMethods,
+  transformWrappers: () => transformWrappers,
+  zodToMiniPlugin: () => zodToMiniPlugin
+});
+var init_src = __esm({
+  "../zod-to-mini/src/index.ts"() {
+    init_transforms();
+    init_vite_plugin();
+  }
+});
+
+// src/cli/codemod.ts
+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');
+  const dir = resolve(process.cwd(), targetDir);
+  const files = globSync(["**/*.ts", "**/*.tsx"], {
+    cwd: dir,
+    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}/`
+  );
+  console.log("");
+  let totalChanged = 0;
+  for (const filePath of files) {
+    const code = readFileSync(filePath, "utf-8");
+    if (!code.includes("'zod'") && !code.includes('"zod"')) continue;
+    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);
+    transformImports2(sf);
+    for (const imp of sf.getImportDeclarations()) {
+      const spec = imp.getModuleSpecifierValue();
+      if (spec === "zodvex/core") imp.setModuleSpecifier("zodvex/mini");
+    }
+    output = sf.getFullText();
+    if (output !== code) {
+      totalChanged++;
+      const rel = relative(process.cwd(), filePath);
+      if (options.dryRun) {
+        console.log(`  would change: ${rel}`);
+      } else {
+        writeFileSync(filePath, output);
+        console.log(`  changed: ${rel}`);
+      }
+    }
+  }
+  console.log("");
+  console.log(
+    `[zodvex codemod] ${totalChanged} file(s) ${options.dryRun ? "would be changed" : "changed"}.`
+  );
+  if (!options.dryRun && totalChanged > 0) {
+    console.log("");
+    console.log("Next steps:");
+    console.log("  1. Run `zodvex generate --mini` to regenerate codegen output");
+    console.log("  2. Run your type-checker and tests to verify");
+    console.log("  3. To undo: git restore " + targetDir + "/");
+  }
+}
+var init_codemod = __esm({
+  "src/cli/codemod.ts"() {
+  }
+});
 
 // src/meta.ts
 var META_KEY = "__zodvexMeta";
@@ -1074,6 +1594,18 @@ async function main() {
       }
       break;
     }
+    case "codemod": {
+      const toMini = process.argv.includes("--to-mini");
+      if (!toMini) {
+        console.error("[zodvex] No codemod specified. Available: --to-mini");
+        process.exit(1);
+      }
+      const dryRun = process.argv.includes("--dry-run");
+      const targetDir = process.argv.slice(3).find((a) => !a.startsWith("--")) ?? "convex";
+      const { runToMiniCodemod: runToMiniCodemod2 } = await Promise.resolve().then(() => (init_codemod(), codemod_exports));
+      await runToMiniCodemod2(targetDir, { dryRun });
+      break;
+    }
     case "help":
     case "--help":
     case "-h":
@@ -1096,6 +1628,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 help                            Show this help message
 
 Flags: