zodvex 0.7.1 → 0.7.2-beta.1

package/dist/cli/index.js

@@ -3,6 +3,8 @@ 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 { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
 import { z } from 'zod';
 import { $ZodCodec, $ZodNumber, $ZodCustom, $ZodType, $ZodOptional, $ZodNullable, $ZodObject, $ZodUnion, $ZodArray, $ZodRecord, $ZodTuple, clone, $ZodString, $ZodBoolean, $ZodNull, $ZodUndefined, $ZodAny, $ZodEnum, $ZodLiteral, $ZodDiscriminatedUnion } from 'zod/v4/core';
 import 'convex/values';
@@ -318,7 +320,7 @@ function getMethodName(call) {
   if (expr.getKind() !== SyntaxKind.PropertyAccessExpression) return null;
   return expr.getName();
 }
-function transformWrappers(file) {
+function transformWrappers(file, typeChecker) {
   let count = 0;
   const calls = file.getDescendantsOfKind(SyntaxKind.CallExpression).reverse();
   for (const call of calls) {
@@ -328,6 +330,18 @@ function transformWrappers(file) {
     if (call.getArguments().length > 0) continue;
     const obj = getCallObject(call);
     if (!obj) continue;
+    if (isNamespaceCall(obj)) continue;
+    let isSchema;
+    if (typeChecker) {
+      const typeResult = isZodSchemaByType(call, typeChecker);
+      isSchema = typeResult === true || typeResult === null && isLikelySchemaExpr(obj);
+    } else {
+      isSchema = isLikelySchemaExpr(obj);
+    }
+    if (!isSchema && isSchemaVariable(call, obj.trim())) {
+      isSchema = true;
+    }
+    if (!isSchema) continue;
     call.replaceWithText(`z.${method}(${obj})`);
     count++;
   }
@@ -337,8 +351,9 @@ 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;
+  const normalized = obj.trim().replace(/^\(+/, "").replace(/\s+as\s+[\w$<>,\s|&[\]]+\)*\s*$/, "").trim();
+  if (normalized.match(/^z\.\w+\(/)) return true;
+  if (normalized.match(/^zx\.\w+\(/)) return true;
   return false;
 }
 function isSchemaVariable(call, varName) {
@@ -561,6 +576,17 @@ function findObjectOnlyMethods(file) {
   }
   return results;
 }
+function ensureZImport(file) {
+  const text = file.getFullText();
+  if (!/\bz\./.test(text)) return;
+  const hasZImport = file.getImportDeclarations().some((imp) => imp.getNamedImports().some((n) => n.getName() === "z"));
+  if (hasZImport) return;
+  if (/^\s*(?:const|let|var)\s+z\s*[=:]/m.test(text)) return;
+  file.addImportDeclaration({
+    moduleSpecifier: "zod/mini",
+    namedImports: [{ name: "z" }]
+  });
+}
 function transformImports(file) {
   let count = 0;
   const imports = file.getImportDeclarations();
@@ -708,7 +734,7 @@ function transformFile(file, typeChecker) {
   let propertyAccessors = 0;
   for (let i = 0; i < 10; i++) {
     const cr = transformConstructorReplacements(file);
-    const w = transformWrappers(file);
+    const w = transformWrappers(file, typeChecker);
     const c = transformChecks(file);
     const m = transformMethods(file, typeChecker);
     const pa = transformPropertyAccessors(file, typeChecker);
@@ -722,6 +748,7 @@ function transformFile(file, typeChecker) {
   const classRefs = transformClassRefs(file);
   const objectOnlyWarnings = findObjectOnlyMethods(file);
   const propertyAccessWarnings = findInternalPropertyAccess(file, typeChecker);
+  ensureZImport(file);
   const imports = 0;
   return {
     filePath,
@@ -1002,6 +1029,20 @@ function readMeta(target) {
   }
   return target[META_KEY];
 }
+var CODEC_BRAND_KEY = "__zodvexCodecBrand";
+function attachCodecBrand(target, brand) {
+  Object.defineProperty(target, CODEC_BRAND_KEY, {
+    value: brand,
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
+}
+function readCodecBrand(target) {
+  if (target == null || typeof target !== "object") return void 0;
+  const value = target[CODEC_BRAND_KEY];
+  return typeof value === "string" ? value : void 0;
+}
 var metadata = /* @__PURE__ */ new WeakMap();
 var registryHelpers = {
   getMetadata: (type) => metadata.get(type),
@@ -1042,8 +1083,10 @@ function id(tableName) {
   branded._tableName = tableName;
   return branded;
 }
-function codec(wire, runtime, transforms) {
-  return zodvexCodec(wire, runtime, transforms);
+function codec(wire, runtime, transforms, opts) {
+  const built = zodvexCodec(wire, runtime, transforms);
+  if (opts?.brand) attachCodecBrand(built, opts.brand);
+  return built;
 }
 function sharedWeakMap(name) {
   const key = /* @__PURE__ */ Symbol.for(`zodvex.zx.cache.${name}`);
@@ -1528,7 +1571,7 @@ async function discoverModules(convexDir2) {
       "crons.ts",
       "crons.js"
     ]
-  });
+  }).sort();
   try {
     for (const file of files) {
       const absPath = path3.resolve(convexDir2, file);
@@ -1689,7 +1732,35 @@ var HEADER = `// AUTO-GENERATED by zodvex \u2014 do not edit
 `;
 function fingerprintCodec(schema) {
   if (!(schema instanceof $ZodCodec)) return "";
-  return `${zodToSource(schema._zod.def.in)}|${zodToSource(schema._zod.def.out)}`;
+  const def = schema._zod.def;
+  const transform = typeof def.transform === "function" ? def.transform.toString() : "";
+  const reverse = typeof def.reverseTransform === "function" ? def.reverseTransform.toString() : "";
+  return `${fingerprintLeaf(def.in)}|${fingerprintLeaf(def.out)}|${transform}|${reverse}`;
+}
+function fingerprintLeaf(schema) {
+  return `${zodToSource(schema)}#${fingerprintChecks(schema)}`;
+}
+function fingerprintChecks(schema) {
+  const checks = schema?._zod?.def?.checks;
+  if (!Array.isArray(checks) || checks.length === 0) return "";
+  const parts = [];
+  for (const check of checks) {
+    const def = check?._zod?.def;
+    if (!def) continue;
+    const checkType = def.check ?? def.type ?? "check";
+    const data = {};
+    for (const [k, v7] of Object.entries(def)) {
+      if (k === "check" || k === "type" || k === "error" || k === "message") continue;
+      const t = typeof v7;
+      if (t === "string" || t === "number" || t === "boolean" || v7 === null) {
+        data[k] = v7;
+      } else if (v7 instanceof RegExp) {
+        data[k] = v7.source;
+      }
+    }
+    parts.push(`${checkType}(${JSON.stringify(data)})`);
+  }
+  return parts.sort().join("&");
 }
 function generateSchemaFile(models) {
   const exports$1 = models.map((m) => {
@@ -1776,6 +1847,30 @@ function deriveCodecVarName(modelExportName, accessPath) {
   return `_${prefix}${fieldPart[0].toUpperCase() + fieldPart.slice(1)}`;
 }
 function generateApiFile(functions, models, codecs, modelCodecs, functionCodecs, options) {
+  const sortedModels = [...models].sort(
+    (a, b) => `${a.sourceFile}|${a.exportName}`.localeCompare(`${b.sourceFile}|${b.exportName}`)
+  );
+  const sortedFunctions = [...functions].sort(
+    (a, b) => a.functionPath.localeCompare(b.functionPath)
+  );
+  const sortedCodecs = codecs ? [...codecs].sort(
+    (a, b) => `${a.sourceFile}|${a.exportName}`.localeCompare(`${b.sourceFile}|${b.exportName}`)
+  ) : void 0;
+  const sortedModelCodecs = modelCodecs ? [...modelCodecs].sort(
+    (a, b) => `${a.modelSourceFile}|${a.modelExportName}|${a.schemaKey}|${a.accessPath}`.localeCompare(
+      `${b.modelSourceFile}|${b.modelExportName}|${b.schemaKey}|${b.accessPath}`
+    )
+  ) : void 0;
+  const sortedFunctionCodecs = functionCodecs ? [...functionCodecs].sort(
+    (a, b) => `${a.functionSourceFile}|${a.functionExportName}|${a.schemaSource}|${a.accessPath}`.localeCompare(
+      `${b.functionSourceFile}|${b.functionExportName}|${b.schemaSource}|${b.accessPath}`
+    )
+  ) : void 0;
+  models = sortedModels;
+  functions = sortedFunctions;
+  codecs = sortedCodecs;
+  modelCodecs = sortedModelCodecs;
+  functionCodecs = sortedFunctionCodecs;
   const identityMap = /* @__PURE__ */ new Map();
   const neededModelImports = /* @__PURE__ */ new Set();
   for (const model of models) {
@@ -1859,21 +1954,74 @@ function generateApiFile(functions, models, codecs, modelCodecs, functionCodecs,
   }
   if (functionCodecs) {
     const fingerprintMap = /* @__PURE__ */ new Map();
+    const brandMap = /* @__PURE__ */ new Map();
+    const codecSchemaToSourceFile = /* @__PURE__ */ new Map();
+    for (const c of codecs ?? []) {
+      codecSchemaToSourceFile.set(c.schema, c.sourceFile);
+    }
+    for (const mc of modelCodecs ?? []) {
+      codecSchemaToSourceFile.set(mc.codec, mc.modelSourceFile);
+    }
     for (const [codecSchema, ref] of codecMap) {
+      const sourceFile = codecSchemaToSourceFile.get(codecSchema);
+      const brand = readCodecBrand(codecSchema);
+      const candidate = { ref, sourceFile, brand };
       const fp = fingerprintCodec(codecSchema);
-      if (fp) fingerprintMap.set(fp, ref);
+      if (fp) {
+        const existing = fingerprintMap.get(fp);
+        if (existing) existing.push(candidate);
+        else fingerprintMap.set(fp, [candidate]);
+      }
+      if (brand) {
+        const existing = brandMap.get(brand);
+        if (existing) existing.push(candidate);
+        else brandMap.set(brand, [candidate]);
+      }
     }
+    const undiscoverable = [];
     for (const fc of functionCodecs) {
       if (codecMap.has(fc.codec)) continue;
-      const fp = fingerprintCodec(fc.codec);
-      const matchingRef = fp ? fingerprintMap.get(fp) : void 0;
-      if (matchingRef) {
-        codecMap.set(fc.codec, matchingRef);
-      } else {
-        console.warn(
-          `[zodvex] Warning: Codec in ${fc.functionExportName}() (${fc.accessPath}) has no matching model or exported codec. Export it standalone for full client-side codec support.`
+      const brand = readCodecBrand(fc.codec);
+      let candidates = brand ? brandMap.get(brand) : void 0;
+      if (!candidates || candidates.length === 0) {
+        const fp = fingerprintCodec(fc.codec);
+        candidates = (fp ? fingerprintMap.get(fp) : void 0)?.filter(
+          (c) => c.brand === void 0 || c.brand === brand
         );
       }
+      if (!candidates || candidates.length === 0) {
+        undiscoverable.push({ fn: fc.functionExportName, path: fc.accessPath });
+        continue;
+      }
+      let chosen;
+      if (candidates.length === 1) {
+        chosen = candidates[0].ref;
+      } else {
+        const sameFile = candidates.filter((c) => c.sourceFile === fc.functionSourceFile);
+        if (sameFile.length === 1) {
+          chosen = sameFile[0].ref;
+        } else {
+          const sorted = [...candidates].sort(
+            (a, b) => `${a.sourceFile ?? ""}|${a.ref.exportName}`.localeCompare(
+              `${b.sourceFile ?? ""}|${b.ref.exportName}`
+            )
+          );
+          chosen = sorted[0].ref;
+          if (!brand) {
+            console.warn(
+              `[zodvex] Note: Codec in ${fc.functionExportName}() (${fc.accessPath}) matches ${candidates.length} fingerprint-equivalent codecs (${candidates.map((c) => c.ref.exportName).join(", ")}). Referencing '${chosen.exportName}'. Export the codec standalone or give it a brand if you want the reference to be explicit.`
+            );
+          }
+        }
+      }
+      codecMap.set(fc.codec, chosen);
+    }
+    if (undiscoverable.length > 0) {
+      const list = undiscoverable.map((u) => `  - ${u.fn}() at ${u.path}`).join("\n");
+      throw new Error(
+        `[zodvex] ${undiscoverable.length} codec(s) in function args/returns have no importable reference (not exported standalone, not embedded in a model). The generated client cannot encode or decode them, which silently breaks the codec boundary. Export each codec standalone (or add it to a model) so codegen can import it:
+${list}`
+      );
     }
   }
   const zodToSourceCtx = {
@@ -1932,15 +2080,17 @@ function generateApiFile(functions, models, codecs, modelCodecs, functionCodecs,
   if (coreImports.length > 0) {
     imports.push(`import { ${coreImports.join(", ")} } from '${zodvexImport}'`);
   }
-  for (const exportName of neededModelImports) {
+  for (const exportName of [...neededModelImports].sort()) {
     const model = models.find((m) => m.exportName === exportName);
     if (model) {
       const importPath = `../${model.sourceFile.replace(/\.ts$/, ".js")}`;
       imports.push(`import { ${exportName} } from '${importPath}'`);
     }
   }
-  for (const [importPath, exportNames] of zodToSourceCtx.neededCodecImports) {
+  const sortedCodecImportPaths = [...zodToSourceCtx.neededCodecImports.keys()].sort();
+  for (const importPath of sortedCodecImportPaths) {
     if (importPath === MODEL_CODEC_SENTINEL) continue;
+    const exportNames = zodToSourceCtx.neededCodecImports.get(importPath) ?? /* @__PURE__ */ new Set();
     const names = Array.from(exportNames).sort().join(", ");
     imports.push(`import { ${names} } from '${importPath}'`);
   }
@@ -2080,13 +2230,9 @@ async function dev(convexDir2, options) {
       return;
     }
     if (debounceTimer) clearTimeout(debounceTimer);
-    debounceTimer = setTimeout(async () => {
+    debounceTimer = setTimeout(() => {
       console.log("[zodvex] Regenerating...");
-      try {
-        await generate(resolved, options);
-      } catch (err) {
-        console.error("[zodvex] Generation failed:", err.message);
-      }
+      void regenerate(resolved, options);
     }, 300);
   });
   process.on("SIGINT", () => {
@@ -2095,6 +2241,22 @@ async function dev(convexDir2, options) {
     process.exit(0);
   });
 }
+function regenerate(resolved, options) {
+  const cliEntry = fileURLToPath(new URL("./index.js", import.meta.url));
+  const args = [cliEntry, "generate", resolved];
+  if (options?.mini) args.push("--mini");
+  return new Promise((resolve2) => {
+    const child = spawn(process.execPath, args, { stdio: "inherit" });
+    child.on("exit", (code) => {
+      if (code !== 0) console.error(`[zodvex] Regeneration exited with code ${code}`);
+      resolve2();
+    });
+    child.on("error", (err) => {
+      console.error("[zodvex] Failed to spawn regeneration:", err.message);
+      resolve2();
+    });
+  });
+}
 function writeStubApi(zodvexDir) {
   fs2.mkdirSync(zodvexDir, { recursive: true });
   fs2.writeFileSync(