zodvex 0.7.7-beta.1 → 0.7.7

package/dist/cli/index.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
-import fs2, { readFileSync, writeFileSync, existsSync } from 'fs';
-import path3, { resolve, relative, join } from 'path';
+import fs3, { readFileSync, writeFileSync, existsSync } from 'fs';
+import path4, { 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 { $ZodCodec, $ZodType, $ZodOptional, $ZodNullable, $ZodObject, $ZodUnion, $ZodArray, $ZodRecord, $ZodTuple, clone, $ZodString, $ZodNumber, $ZodBoolean, $ZodNull, $ZodUndefined, $ZodAny, $ZodEnum, $ZodLiteral, $ZodDiscriminatedUnion } from 'zod/v4/core';
 import 'convex/values';
 
 var __defProp = Object.defineProperty;
@@ -62,12 +62,12 @@ function gitignoreEntry(content) {
   return lines.join("\n");
 }
 function generateStubs(convexDir2) {
-  const zodvexDir = path3.join(convexDir2, "_zodvex");
-  fs2.mkdirSync(zodvexDir, { recursive: true });
+  const zodvexDir = path4.join(convexDir2, "_zodvex");
+  fs3.mkdirSync(zodvexDir, { recursive: true });
   const apiStub = `// Auto-generated stub. Run \`zodvex generate\` to populate.
 export const zodvexRegistry = {} as const
 `;
-  fs2.writeFileSync(path3.join(zodvexDir, "api.ts"), apiStub);
+  fs3.writeFileSync(path4.join(zodvexDir, "api.ts"), apiStub);
   const clientStub = `// Auto-generated stub. Run \`zodvex generate\` to populate.
 import { zodvexRegistry } from './api'
 
@@ -75,11 +75,11 @@ export const useZodQuery = undefined as any
 export const useZodMutation = undefined as any
 export const createClient = undefined as any
 `;
-  fs2.writeFileSync(path3.join(zodvexDir, "client.ts"), clientStub);
+  fs3.writeFileSync(path4.join(zodvexDir, "client.ts"), clientStub);
 }
 async function init() {
-  const convexDir2 = path3.resolve("convex");
-  if (!fs2.existsSync(convexDir2)) {
+  const convexDir2 = path4.resolve("convex");
+  if (!fs3.existsSync(convexDir2)) {
     console.error("[zodvex] No convex/ directory found. Run this from your project root.");
     return;
   }
@@ -100,14 +100,14 @@ __export(migrate_exports, {
 function collectFiles(dir) {
   const results = [];
   function walk(current) {
-    const entries = fs2.readdirSync(current, { withFileTypes: true });
+    const entries = fs3.readdirSync(current, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (!SKIP_DIRS.has(entry.name)) {
-          walk(path3.join(current, entry.name));
+          walk(path4.join(current, entry.name));
         }
-      } else if (entry.isFile() && TS_EXTENSIONS.has(path3.extname(entry.name))) {
-        results.push(path3.join(current, entry.name));
+      } else if (entry.isFile() && TS_EXTENSIONS.has(path4.extname(entry.name))) {
+        results.push(path4.join(current, entry.name));
       }
     }
   }
@@ -204,7 +204,7 @@ function migrate(dir, options) {
   let wouldChange = 0;
   const allDeprecations = [];
   for (const filePath of files) {
-    const original = fs2.readFileSync(filePath, "utf-8");
+    const original = fs3.readFileSync(filePath, "utf-8");
     let content = original;
     content = applyIdentifierRenames(content);
     content = applyZidTransform(content);
@@ -214,7 +214,7 @@ function migrate(dir, options) {
       if (options.dryRun) {
         wouldChange++;
       } else {
-        fs2.writeFileSync(filePath, content);
+        fs3.writeFileSync(filePath, content);
         filesChanged++;
       }
     }
@@ -1054,18 +1054,34 @@ function zodvexCodec(wire, runtime, transforms) {
   return z.codec(wire, runtime, transforms);
 }
 
+// src/internal/zxDateBrand.ts
+var ZX_DATE_BRAND = /* @__PURE__ */ Symbol.for("zodvex.zxDate");
+function brandZxDate(codec2) {
+  codec2[ZX_DATE_BRAND] = true;
+  const def = codec2._zod?.def;
+  if (def) def[ZX_DATE_BRAND] = true;
+  return codec2;
+}
+function isZxDateCodec(schema) {
+  if (!schema || typeof schema !== "object") return false;
+  const s = schema;
+  return s[ZX_DATE_BRAND] === true || s._zod?.def?.[ZX_DATE_BRAND] === true;
+}
+
 // src/internal/zx.ts
 function date() {
-  return zodvexCodec(
-    z.number(),
-    // Wire: timestamp
-    z.custom((val) => val instanceof Date, {
-      message: "Expected Date instance"
-    }),
-    {
-      decode: (timestamp) => new Date(timestamp),
-      encode: (date2) => date2.getTime()
-    }
+  return brandZxDate(
+    zodvexCodec(
+      z.number(),
+      // Wire: timestamp
+      z.custom((val) => val instanceof Date, {
+        message: "Expected Date instance"
+      }),
+      {
+        decode: (timestamp) => new Date(timestamp),
+        encode: (date2) => date2.getTime()
+      }
+    )
   );
 }
 function id(tableName) {
@@ -1304,9 +1320,35 @@ function createSchemaUpdateSchema(name, inputSchema) {
   }
   return inputSchema;
 }
-var HOOKS_SOURCE = `
+function buildHooksSource(aliases) {
+  return `
+import { pathToFileURL } from 'node:url';
+
 const EXT_CANDIDATES = ['.ts', '.tsx', '.mts', '.js', '.mjs', '.jsx', '/index.ts', '/index.js'];
 
+// tsconfig path aliases compiled by loadTsconfigAliases (#99). Bun resolves
+// these natively; Node's ESM loader needs them replayed here.
+const ALIASES = ${JSON.stringify(aliases)};
+
+function aliasCandidates(specifier) {
+  const out = [];
+  for (const a of ALIASES) {
+    if (a.star) {
+      if (
+        specifier.length >= a.prefix.length + a.suffix.length &&
+        specifier.startsWith(a.prefix) &&
+        specifier.endsWith(a.suffix)
+      ) {
+        const captured = specifier.slice(a.prefix.length, specifier.length - a.suffix.length);
+        for (const t of a.targets) out.push(t.prefix + captured + t.suffix);
+      }
+    } else if (specifier === a.prefix) {
+      for (const t of a.targets) out.push(t.prefix);
+    }
+  }
+  return out;
+}
+
 export async function resolve(specifier, context, nextResolve) {
   if (/_generated\\/api(\\.[mc]?[jt]sx?)?$/.test(specifier)) {
     return { shortCircuit: true, url: 'zodvex-stub://api' };
@@ -1314,6 +1356,15 @@ export async function resolve(specifier, context, nextResolve) {
   try {
     return await nextResolve(specifier, context);
   } catch (err) {
+    // tsconfig path aliases (e.g. '@/convex/...'). Try each mapped absolute
+    // path as-is, then with the usual extension/index candidates.
+    for (const base of aliasCandidates(specifier)) {
+      for (const ext of ['', ...EXT_CANDIDATES]) {
+        try {
+          return await nextResolve(pathToFileURL(base + ext).href, context);
+        } catch {}
+      }
+    }
     // Convex code uses extensionless relative imports (bundler resolution).
     // Bun resolves those natively; Node's ESM loader does not \u2014 retry with
     // the usual extension candidates before giving up.
@@ -1358,8 +1409,9 @@ export function load(url, context, nextLoad) {
   return nextLoad(url, context);
 }
 `;
+}
 var hooksRegistered = false;
-function registerDiscoveryHooks() {
+function registerDiscoveryHooks(aliases = []) {
   if (hooksRegistered) return true;
   try {
     const nodeModule = typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("node:module") : (
@@ -1368,7 +1420,7 @@ function registerDiscoveryHooks() {
     );
     const { register } = nodeModule;
     if (typeof register !== "function") return false;
-    register(`data:text/javascript,${encodeURIComponent(HOOKS_SOURCE)}`);
+    register(`data:text/javascript,${encodeURIComponent(buildHooksSource(aliases))}`);
     hooksRegistered = true;
     return true;
   } catch {
@@ -1393,22 +1445,22 @@ export const components = p;
 export const httpRouter = p;
 `;
 function writeGeneratedStubs(convexDir2) {
-  const generatedDir = path3.join(convexDir2, "_generated");
-  const apiPath = path3.join(generatedDir, "api.ts");
+  const generatedDir = path4.join(convexDir2, "_generated");
+  const apiPath = path4.join(generatedDir, "api.ts");
   let original;
   try {
-    original = fs2.readFileSync(apiPath, "utf8");
+    original = fs3.readFileSync(apiPath, "utf8");
   } catch {
     original = null;
   }
-  fs2.mkdirSync(generatedDir, { recursive: true });
-  fs2.writeFileSync(apiPath, PROXY_STUB_API);
+  fs3.mkdirSync(generatedDir, { recursive: true });
+  fs3.writeFileSync(apiPath, PROXY_STUB_API);
   return () => {
     if (original !== null) {
-      fs2.writeFileSync(apiPath, original);
+      fs3.writeFileSync(apiPath, original);
     } else {
       try {
-        fs2.unlinkSync(apiPath);
+        fs3.unlinkSync(apiPath);
       } catch {
       }
     }
@@ -1420,8 +1472,7 @@ function findCodec(schema) {
   let current = schema;
   for (let i = 0; i < 10; i++) {
     if (current instanceof $ZodCodec) {
-      const isZxDate = current._zod.def.in instanceof $ZodNumber && current._zod.def.out instanceof $ZodCustom;
-      if (isZxDate) return void 0;
+      if (isZxDateCodec(current)) return void 0;
       return current;
     }
     if (current instanceof $ZodOptional || current instanceof $ZodNullable) {
@@ -1432,6 +1483,134 @@ function findCodec(schema) {
   }
   return void 0;
 }
+function stripJsonComments(input) {
+  let out = "";
+  let inString = false;
+  let inLine = false;
+  let inBlock = false;
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    const next = input[i + 1];
+    if (inLine) {
+      if (ch === "\n") {
+        inLine = false;
+        out += ch;
+      }
+      continue;
+    }
+    if (inBlock) {
+      if (ch === "*" && next === "/") {
+        inBlock = false;
+        i++;
+      }
+      continue;
+    }
+    if (inString) {
+      out += ch;
+      if (ch === "\\") {
+        out += next ?? "";
+        i++;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      out += ch;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      inLine = true;
+      i++;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      inBlock = true;
+      i++;
+      continue;
+    }
+    out += ch;
+  }
+  return out.replace(/,\s*([}\]])/g, "$1");
+}
+function readTsconfig(configPath) {
+  try {
+    const raw = fs3.readFileSync(configPath, "utf8");
+    return JSON.parse(stripJsonComments(raw));
+  } catch {
+    return null;
+  }
+}
+function resolvePathsFromConfig(configPath, seen) {
+  const abs = path4.resolve(configPath);
+  if (seen.has(abs)) return null;
+  seen.add(abs);
+  const config = readTsconfig(abs);
+  if (!config) return null;
+  const dir = path4.dirname(abs);
+  const own = config.compilerOptions?.paths;
+  if (own) {
+    const baseUrl = config.compilerOptions?.baseUrl;
+    return { paths: own, baseDir: baseUrl ? path4.resolve(dir, baseUrl) : dir };
+  }
+  const parents = config.extends == null ? [] : [].concat(config.extends);
+  for (const ref of parents) {
+    if (!ref.startsWith(".") && !path4.isAbsolute(ref)) continue;
+    let target = path4.resolve(dir, ref);
+    if (!target.endsWith(".json")) target += ".json";
+    const found = resolvePathsFromConfig(target, seen);
+    if (found) {
+      const childBase = config.compilerOptions?.baseUrl;
+      return childBase ? { paths: found.paths, baseDir: path4.resolve(dir, childBase) } : found;
+    }
+  }
+  return null;
+}
+function compileAliases(paths, baseDir) {
+  const entries = [];
+  for (const [pattern, targets] of Object.entries(paths)) {
+    const starIdx = pattern.indexOf("*");
+    const star = starIdx !== -1;
+    const prefix = star ? pattern.slice(0, starIdx) : pattern;
+    const suffix = star ? pattern.slice(starIdx + 1) : "";
+    const compiled = targets.map((t) => {
+      const tStar = t.indexOf("*");
+      const tPrefix = path4.resolve(baseDir, tStar === -1 ? t : t.slice(0, tStar));
+      const sep = tStar !== -1 && t.slice(0, tStar).endsWith("/") ? path4.sep : "";
+      return {
+        prefix: tPrefix + sep,
+        suffix: tStar === -1 ? "" : t.slice(tStar + 1)
+      };
+    });
+    entries.push({ prefix, suffix, star, targets: compiled });
+  }
+  return entries;
+}
+function loadTsconfigAliases(convexDir2) {
+  const entries = [];
+  const seenPatterns = /* @__PURE__ */ new Set();
+  let dir = path4.resolve(convexDir2);
+  for (let depth = 0; depth < 10; depth++) {
+    const configPath = path4.join(dir, "tsconfig.json");
+    if (fs3.existsSync(configPath)) {
+      const found = resolvePathsFromConfig(configPath, /* @__PURE__ */ new Set());
+      if (found) {
+        for (const entry of compileAliases(found.paths, found.baseDir)) {
+          const key = `${entry.prefix}*${entry.suffix}`;
+          if (!seenPatterns.has(key)) {
+            seenPatterns.add(key);
+            entries.push(entry);
+          }
+        }
+      }
+    }
+    const parent = path4.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return entries;
+}
 
 // src/public/codegen/discover.ts
 function walkSchemaRecursive(schema, accessPath, visited, seenCodecs, results) {
@@ -1575,7 +1754,7 @@ async function discoverModules(convexDir2) {
   const models = [];
   const functions = [];
   const codecs = [];
-  registerDiscoveryHooks();
+  registerDiscoveryHooks(loadTsconfigAliases(convexDir2));
   const cleanupStubs = writeGeneratedStubs(convexDir2);
   const files = globSync(["**/*.{ts,js}"], {
     cwd: convexDir2,
@@ -1595,15 +1774,15 @@ async function discoverModules(convexDir2) {
       "crons.js"
     ]
   }).sort();
-  let importFailures = 0;
+  const failedImports = [];
   try {
     for (const file of files) {
-      const absPath = path3.resolve(convexDir2, file);
+      const absPath = path4.resolve(convexDir2, file);
       let moduleExports;
       try {
         moduleExports = await import(absPath);
       } catch (err) {
-        importFailures++;
+        failedImports.push({ file, message: err.message });
         console.warn(`[zodvex] Warning: Failed to import ${file}:`, err.message);
         continue;
       }
@@ -1647,8 +1826,7 @@ async function discoverModules(convexDir2) {
           }
         }
         if (value instanceof $ZodCodec) {
-          const isZxDate = value._zod.def.in instanceof $ZodNumber && value._zod.def.out instanceof $ZodCustom;
-          if (!isZxDate) {
+          if (!isZxDateCodec(value)) {
             if (!codecs.some((c) => c.schema === value)) {
               codecs.push({
                 exportName,
@@ -1671,9 +1849,14 @@ async function discoverModules(convexDir2) {
       modelCodecs.push(...found);
     }
     const functionCodecs = walkFunctionCodecs(functions);
-    if (importFailures > 0 && models.length === 0 && functions.length === 0) {
+    if (failedImports.length > 0 && !process.env.ZODVEX_ALLOW_IMPORT_FAILURES) {
+      const shown = failedImports.slice(0, 10).map((f) => `  - ${f.file}: ${f.message}`).join("\n");
+      const more = failedImports.length > 10 ? `
+  \u2026 and ${failedImports.length - 10} more` : "";
       throw new Error(
-        `[zodvex] Discovery imported 0 modules (${importFailures} file(s) failed to load). Importing TypeScript at runtime requires Bun or Node >= 22.18 (native type stripping). Re-run with Bun (\`bunx zodvex generate\`) or upgrade Node.`
+        `[zodvex] ${failedImports.length} module(s) failed to import during discovery \u2014 the generated registry would be incomplete:
+${shown}${more}
+Common causes: Node < 22.18 (no native TypeScript type stripping \u2014 use Bun or upgrade Node), or an import style the discovery resolver does not handle. tsconfig path aliases and extensionless relative imports are supported. Set ZODVEX_ALLOW_IMPORT_FAILURES=1 to generate anyway (skipping the failed modules).`
       );
     }
     return { models, functions, codecs, modelCodecs, functionCodecs };
@@ -1698,7 +1881,7 @@ function zodToSource(schema, ctx) {
       return `zx.id("${tableName}")`;
     }
   }
-  if (schema instanceof $ZodCodec && schema._zod.def.in instanceof $ZodNumber && schema._zod.def.out instanceof $ZodCustom) {
+  if (schema instanceof $ZodCodec && isZxDateCodec(schema)) {
     return "zx.date()";
   }
   if (schema instanceof $ZodCodec) {
@@ -2221,29 +2404,39 @@ ${dtsDeclarations.join("\n")}
 // src/public/cli/commands.ts
 async function generate(convexDir2, options) {
   const resolved = resolveConvexDir(convexDir2);
-  const zodvexDir = path3.join(resolved, "_zodvex");
-  writeStubApi(zodvexDir);
-  const result = await discoverModules(resolved);
-  const schemaContent = generateSchemaFile(result.models);
-  const apiContent = generateApiFile(
-    result.functions,
-    result.models,
-    result.codecs,
-    result.modelCodecs,
-    result.functionCodecs,
-    { mini: options?.mini }
-  );
-  const clientContent = generateClientFile({ mini: options?.mini });
-  const serverContent = generateServerFile();
-  fs2.mkdirSync(zodvexDir, { recursive: true });
-  writeIfChanged(path3.join(zodvexDir, "schema.js"), schemaContent.js);
-  writeIfChanged(path3.join(zodvexDir, "schema.d.ts"), schemaContent.dts);
-  writeIfChanged(path3.join(zodvexDir, "api.js"), apiContent.js);
-  writeIfChanged(path3.join(zodvexDir, "api.d.ts"), apiContent.dts);
-  writeIfChanged(path3.join(zodvexDir, "client.js"), clientContent.js);
-  writeIfChanged(path3.join(zodvexDir, "client.d.ts"), clientContent.dts);
-  writeIfChanged(path3.join(zodvexDir, "server.js"), serverContent.js);
-  writeIfChanged(path3.join(zodvexDir, "server.d.ts"), serverContent.dts);
+  const zodvexDir = path4.join(resolved, "_zodvex");
+  const restoreStubbedApi = writeStubApi(zodvexDir);
+  let result;
+  let schemaContent;
+  let apiContent;
+  let clientContent;
+  let serverContent;
+  try {
+    result = await discoverModules(resolved);
+    schemaContent = generateSchemaFile(result.models);
+    apiContent = generateApiFile(
+      result.functions,
+      result.models,
+      result.codecs,
+      result.modelCodecs,
+      result.functionCodecs,
+      { mini: options?.mini }
+    );
+    clientContent = generateClientFile({ mini: options?.mini });
+    serverContent = generateServerFile();
+  } catch (err) {
+    restoreStubbedApi();
+    throw err;
+  }
+  fs3.mkdirSync(zodvexDir, { recursive: true });
+  writeIfChanged(path4.join(zodvexDir, "schema.js"), schemaContent.js);
+  writeIfChanged(path4.join(zodvexDir, "schema.d.ts"), schemaContent.dts);
+  writeIfChanged(path4.join(zodvexDir, "api.js"), apiContent.js);
+  writeIfChanged(path4.join(zodvexDir, "api.d.ts"), apiContent.dts);
+  writeIfChanged(path4.join(zodvexDir, "client.js"), clientContent.js);
+  writeIfChanged(path4.join(zodvexDir, "client.d.ts"), clientContent.dts);
+  writeIfChanged(path4.join(zodvexDir, "server.js"), serverContent.js);
+  writeIfChanged(path4.join(zodvexDir, "server.d.ts"), serverContent.dts);
   const totalCodecs = result.codecs.length + result.modelCodecs.length + result.functionCodecs.length;
   console.log(
     `[zodvex] Generated ${result.models.length} model(s), ${result.functions.length} function(s), ${totalCodecs} codec(s)`
@@ -2254,7 +2447,7 @@ async function dev(convexDir2, options) {
   console.log("[zodvex] Starting watch mode...");
   await generate(resolved, options);
   let debounceTimer = null;
-  const watcher = fs2.watch(resolved, { recursive: true }, (_event, filename) => {
+  const watcher = fs3.watch(resolved, { recursive: true }, (_event, filename) => {
     if (!filename) return;
     if (filename.startsWith("_zodvex") || filename.startsWith("_generated") || !filename.endsWith(".ts") && !filename.endsWith(".js")) {
       return;
@@ -2288,34 +2481,56 @@ function regenerate(resolved, options) {
   });
 }
 function writeStubApi(zodvexDir) {
-  fs2.mkdirSync(zodvexDir, { recursive: true });
-  fs2.writeFileSync(
-    path3.join(zodvexDir, "api.js"),
+  const stubTargets = ["api.js", "api.d.ts"].map((name) => {
+    const filePath = path4.join(zodvexDir, name);
+    let original;
+    try {
+      original = fs3.readFileSync(filePath, "utf-8");
+    } catch {
+      original = null;
+    }
+    return { filePath, original };
+  });
+  fs3.mkdirSync(zodvexDir, { recursive: true });
+  fs3.writeFileSync(
+    path4.join(zodvexDir, "api.js"),
     "// AUTO-GENERATED by zodvex \u2014 do not edit\n// Stub created for codegen bootstrap\n\nexport const zodvexRegistry = {}\n"
   );
-  fs2.writeFileSync(
-    path3.join(zodvexDir, "api.d.ts"),
+  fs3.writeFileSync(
+    path4.join(zodvexDir, "api.d.ts"),
     "// AUTO-GENERATED by zodvex \u2014 do not edit\n// Stub created for codegen bootstrap\n\nexport declare const zodvexRegistry: Record<string, any>\n"
   );
+  return () => {
+    for (const { filePath, original } of stubTargets) {
+      try {
+        if (original !== null) {
+          fs3.writeFileSync(filePath, original);
+        } else {
+          fs3.unlinkSync(filePath);
+        }
+      } catch {
+      }
+    }
+  };
 }
 function writeIfChanged(filePath, content) {
   try {
-    const existing = fs2.readFileSync(filePath, "utf-8");
+    const existing = fs3.readFileSync(filePath, "utf-8");
     if (existing === content) return;
   } catch {
   }
-  fs2.writeFileSync(filePath, content);
+  fs3.writeFileSync(filePath, content);
 }
 function resolveConvexDir(dir) {
   if (dir) {
-    const resolved = path3.resolve(dir);
-    if (!fs2.existsSync(resolved)) {
+    const resolved = path4.resolve(dir);
+    if (!fs3.existsSync(resolved)) {
       throw new Error(`Convex directory not found: ${resolved}`);
     }
     return resolved;
   }
-  const defaultDir = path3.resolve("convex");
-  if (!fs2.existsSync(defaultDir)) {
+  const defaultDir = path4.resolve("convex");
+  if (!fs3.existsSync(defaultDir)) {
     throw new Error("No convex/ directory found. Specify the path: zodvex generate <path>");
   }
   return defaultDir;