on-zero 0.4.3 → 0.4.4

package/dist/esm/generate.mjs

@@ -3,17 +3,20 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from
 import { basename, dirname, resolve } from "node:path";
 import { formatObjectKey, generateGroupedQueriesFile, generateModelsFile, generateReadmeFile, generateSyncedMutationsFile, generateSyncedQueriesFile, generateTablesFile, generateTypesFile, parseColumnType, parseTypeString, shouldSkipObjectKey } from "./generate-helpers.mjs";
 const hash = s => createHash("sha256").update(s).digest("hex");
-let generateCache = {},
-  generateCachePath = "";
+let generateCache = {};
+let generateCachePath = "";
 function getCacheDir() {
   let dir = process.cwd();
-  for (; dir !== "/";) {
+  while (dir !== "/") {
     const nm = resolve(dir, "node_modules");
     if (existsSync(nm)) {
       const cacheDir = resolve(nm, ".on-zero");
-      return existsSync(cacheDir) || mkdirSync(cacheDir, {
-        recursive: !0
-      }), cacheDir;
+      if (!existsSync(cacheDir)) {
+        mkdirSync(cacheDir, {
+          recursive: true
+        });
+      }
+      return cacheDir;
     }
     dir = resolve(dir, "..");
   }
@@ -21,22 +24,28 @@ function getCacheDir() {
 }
 function loadCache() {
   const cacheDir = getCacheDir();
-  if (cacheDir) {
-    generateCachePath = resolve(cacheDir, "generate-cache.json");
-    try {
-      generateCache = JSON.parse(readFileSync(generateCachePath, "utf-8"));
-    } catch {
-      generateCache = {};
-    }
+  if (!cacheDir) return;
+  generateCachePath = resolve(cacheDir, "generate-cache.json");
+  try {
+    generateCache = JSON.parse(readFileSync(generateCachePath, "utf-8"));
+  } catch {
+    generateCache = {};
   }
 }
 function saveCache() {
-  generateCachePath && writeFileSync(generateCachePath, JSON.stringify(generateCache) + `
-`, "utf-8");
+  if (generateCachePath) {
+    writeFileSync(generateCachePath, JSON.stringify(generateCache) + "\n", "utf-8");
+  }
 }
 function writeFileIfChanged(filePath, content) {
   const contentHash = hash(content);
-  return generateCache[filePath] === contentHash && existsSync(filePath) ? !1 : (writeFileSync(filePath, content, "utf-8"), generateCache[filePath] = contentHash, !0);
+  const cachedHash = generateCache[filePath];
+  if (cachedHash === contentHash && existsSync(filePath)) {
+    return false;
+  }
+  writeFileSync(filePath, content, "utf-8");
+  generateCache[filePath] = contentHash;
+  return true;
 }
 function createTypeResolver(ts, files, dir) {
   const configPath = ts.findConfigFile(dir, ts.sys.fileExists, "tsconfig.json");
@@ -44,9 +53,9 @@ function createTypeResolver(ts, files, dir) {
     target: ts.ScriptTarget.Latest,
     module: ts.ModuleKind.ESNext,
     moduleResolution: ts.ModuleResolutionKind.Bundler,
-    strict: !1,
-    skipLibCheck: !0,
-    noEmit: !0
+    strict: false,
+    skipLibCheck: true,
+    noEmit: true
   };
   if (configPath) {
     const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
@@ -59,15 +68,22 @@ function createTypeResolver(ts, files, dir) {
     }
   }
   const fileMap = /* @__PURE__ */new Map();
-  for (const f of files) fileMap.set(f.path, f.content);
-  const host = ts.createCompilerHost(compilerOptions),
-    originalGetSourceFile = host.getSourceFile.bind(host);
+  for (const f of files) {
+    fileMap.set(f.path, f.content);
+  }
+  const host = ts.createCompilerHost(compilerOptions);
+  const originalGetSourceFile = host.getSourceFile.bind(host);
   host.getSourceFile = (fileName, languageVersion, onError) => {
     const content = fileMap.get(fileName);
-    return content !== void 0 ? ts.createSourceFile(fileName, content, languageVersion, !0) : originalGetSourceFile(fileName, languageVersion, onError);
-  }, host.fileExists = fileName => fileMap.has(fileName) || ts.sys.fileExists(fileName), host.readFile = fileName => fileMap.get(fileName) ?? ts.sys.readFile(fileName);
-  const program = ts.createProgram(files.map(f => f.path), compilerOptions, host),
-    checker = program.getTypeChecker();
+    if (content !== void 0) {
+      return ts.createSourceFile(fileName, content, languageVersion, true);
+    }
+    return originalGetSourceFile(fileName, languageVersion, onError);
+  };
+  host.fileExists = fileName => fileMap.has(fileName) || ts.sys.fileExists(fileName);
+  host.readFile = fileName => fileMap.get(fileName) ?? ts.sys.readFile(fileName);
+  const program = ts.createProgram(files.map(f => f.path), compilerOptions, host);
+  const checker = program.getTypeChecker();
   return {
     program,
     checker,
@@ -87,102 +103,146 @@ function createTypeResolver(ts, files, dir) {
 }
 function resolveParamType(ts, resolver, sourceFile, exportName, paramIndex) {
   let result = null;
-  return ts.forEachChild(sourceFile, node => {
-    if (result || !ts.isVariableStatement(node) || !node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword)) return;
+  ts.forEachChild(sourceFile, node => {
+    if (result) return;
+    if (!ts.isVariableStatement(node)) return;
+    if (!node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword)) return;
     const decl = node.declarationList.declarations[0];
-    if (!(!decl || !ts.isVariableDeclaration(decl)) && decl.name.getText(sourceFile) === exportName && decl.initializer && ts.isArrowFunction(decl.initializer)) {
+    if (!decl || !ts.isVariableDeclaration(decl)) return;
+    if (decl.name.getText(sourceFile) !== exportName) return;
+    if (decl.initializer && ts.isArrowFunction(decl.initializer)) {
       const param = decl.initializer.parameters[paramIndex];
-      param?.type && (result = resolver.resolveType(param.type));
+      if (param?.type) {
+        result = resolver.resolveType(param.type);
+      }
     }
-  }), result;
+  });
+  return result;
 }
 function resolveMutationParamTypes(ts, resolver, sourceFile) {
   const resolved = /* @__PURE__ */new Map();
-  return ts.forEachChild(sourceFile, node => {
-    if (!ts.isVariableStatement(node) || !node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword)) return;
+  ts.forEachChild(sourceFile, node => {
+    if (!ts.isVariableStatement(node)) return;
+    if (!node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword)) return;
     const decl = node.declarationList.declarations[0];
-    if (!decl || !ts.isVariableDeclaration(decl) || decl.name.getText(sourceFile) !== "mutate" || !decl.initializer || !ts.isCallExpression(decl.initializer)) return;
+    if (!decl || !ts.isVariableDeclaration(decl)) return;
+    if (decl.name.getText(sourceFile) !== "mutate") return;
+    if (!decl.initializer || !ts.isCallExpression(decl.initializer)) return;
     const args = decl.initializer.arguments;
     let handlersArg = null;
-    for (let i = args.length - 1; i >= 0; i--) if (ts.isObjectLiteralExpression(args[i])) {
-      handlersArg = args[i];
-      break;
+    for (let i = args.length - 1; i >= 0; i--) {
+      if (ts.isObjectLiteralExpression(args[i])) {
+        handlersArg = args[i];
+        break;
+      }
     }
-    if (handlersArg) for (const prop of handlersArg.properties) {
+    if (!handlersArg) return;
+    for (const prop of handlersArg.properties) {
       if (!ts.isPropertyAssignment(prop) && !ts.isMethodDeclaration(prop)) continue;
       const name = prop.name?.getText(sourceFile);
       if (!name) continue;
       let params = null;
       if (ts.isPropertyAssignment(prop)) {
         const init = prop.initializer;
-        (ts.isArrowFunction(init) || ts.isFunctionExpression(init)) && (params = init.parameters);
-      } else ts.isMethodDeclaration(prop) && (params = prop.parameters);
+        if (ts.isArrowFunction(init) || ts.isFunctionExpression(init)) {
+          params = init.parameters;
+        }
+      } else if (ts.isMethodDeclaration(prop)) {
+        params = prop.parameters;
+      }
       if (!params || params.length < 2) continue;
       const typeNode = params[1].type;
       if (!typeNode) continue;
       const expanded = resolver.resolveType(typeNode);
-      expanded && resolved.set(name, expanded);
+      if (expanded) {
+        resolved.set(name, expanded);
+      }
     }
-  }), resolved;
+  });
+  return resolved;
 }
 function extractMutationsFromModel(ts, sourceFile, content, fileName, silent, typeToValibot, resolvedTypes, resolvedTypeToValibot) {
   let mutateNode = null;
-  if (ts.forEachChild(sourceFile, node => {
-    if (!ts.isVariableStatement(node) || !node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword)) return;
+  ts.forEachChild(sourceFile, node => {
+    if (!ts.isVariableStatement(node)) return;
+    if (!node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword)) return;
     const decl = node.declarationList.declarations[0];
-    !decl || !ts.isVariableDeclaration(decl) || decl.name.getText(sourceFile) === "mutate" && decl.initializer && ts.isCallExpression(decl.initializer) && (mutateNode = decl.initializer);
-  }), !mutateNode) return {
-    modelName: basename(fileName, ".ts"),
-    hasCRUD: !1,
-    columns: {},
-    primaryKeys: [],
-    custom: []
-  };
-  const args = mutateNode.arguments,
-    hasCRUD = args.length >= 2;
+    if (!decl || !ts.isVariableDeclaration(decl)) return;
+    if (decl.name.getText(sourceFile) !== "mutate") return;
+    if (decl.initializer && ts.isCallExpression(decl.initializer)) {
+      mutateNode = decl.initializer;
+    }
+  });
+  if (!mutateNode) {
+    return {
+      modelName: basename(fileName, ".ts"),
+      hasCRUD: false,
+      columns: {},
+      primaryKeys: [],
+      custom: []
+    };
+  }
+  const call = mutateNode;
+  const args = call.arguments;
+  const hasCRUD = args.length >= 2;
   let handlersArg = null;
-  args.length === 1 && ts.isObjectLiteralExpression(args[0]) ? handlersArg = args[0] : args.length === 3 && ts.isObjectLiteralExpression(args[2]) && (handlersArg = args[2]);
-  const columns = {},
-    primaryKeys = [];
-  hasCRUD && extractSchemaColumns(ts, sourceFile, columns, primaryKeys);
+  if (args.length === 1 && ts.isObjectLiteralExpression(args[0])) {
+    handlersArg = args[0];
+  } else if (args.length === 3 && ts.isObjectLiteralExpression(args[2])) {
+    handlersArg = args[2];
+  }
+  const columns = {};
+  const primaryKeys = [];
+  if (hasCRUD) {
+    extractSchemaColumns(ts, sourceFile, columns, primaryKeys);
+  }
   const custom = [];
-  if (handlersArg) for (const prop of handlersArg.properties) {
-    if (!ts.isPropertyAssignment(prop) && !ts.isMethodDeclaration(prop)) continue;
-    const name = prop.name?.getText(sourceFile);
-    if (!name) continue;
-    let params = null;
-    if (ts.isPropertyAssignment(prop)) {
-      const init = prop.initializer;
-      (ts.isArrowFunction(init) || ts.isFunctionExpression(init)) && (params = init.parameters);
-    } else ts.isMethodDeclaration(prop) && (params = prop.parameters);
-    if (!params) continue;
-    if (params.length < 2) {
-      custom.push({
-        name,
-        paramType: "void",
-        valibotCode: ""
-      });
-      continue;
-    }
-    const paramType = params[1].type?.getText(sourceFile) || "unknown";
-    if (paramType === "unknown") {
+  if (handlersArg) {
+    for (const prop of handlersArg.properties) {
+      if (!ts.isPropertyAssignment(prop) && !ts.isMethodDeclaration(prop)) continue;
+      const name = prop.name?.getText(sourceFile);
+      if (!name) continue;
+      let params = null;
+      if (ts.isPropertyAssignment(prop)) {
+        const init = prop.initializer;
+        if (ts.isArrowFunction(init) || ts.isFunctionExpression(init)) {
+          params = init.parameters;
+        }
+      } else if (ts.isMethodDeclaration(prop)) {
+        params = prop.parameters;
+      }
+      if (!params) continue;
+      if (params.length < 2) {
+        custom.push({
+          name,
+          paramType: "void",
+          valibotCode: ""
+        });
+        continue;
+      }
+      const secondParam = params[1];
+      const paramType = secondParam.type?.getText(sourceFile) || "unknown";
+      if (paramType === "unknown") {
+        custom.push({
+          name,
+          paramType: "unknown",
+          valibotCode: ""
+        });
+        continue;
+      }
+      let valibotCode = typeToValibot(paramType);
+      if (!valibotCode && resolvedTypes && resolvedTypeToValibot) {
+        const resolvedType = resolvedTypes.get(name);
+        if (resolvedType) {
+          valibotCode = resolvedTypeToValibot(resolvedType);
+        }
+      }
       custom.push({
         name,
-        paramType: "unknown",
-        valibotCode: ""
+        paramType,
+        valibotCode: valibotCode || ""
       });
-      continue;
     }
-    let valibotCode = typeToValibot(paramType);
-    if (!valibotCode && resolvedTypes && resolvedTypeToValibot) {
-      const resolvedType = resolvedTypes.get(name);
-      resolvedType && (valibotCode = resolvedTypeToValibot(resolvedType));
-    }
-    custom.push({
-      name,
-      paramType,
-      valibotCode: valibotCode || ""
-    });
   }
   return {
     modelName: "",
@@ -196,16 +256,24 @@ function extractSchemaColumns(ts, sourceFile, columns, primaryKeys) {
   function visit(node) {
     if (ts.isCallExpression(node)) {
       const text = node.expression.getText(sourceFile);
-      if (text.endsWith(".primaryKey")) for (const arg of node.arguments) ts.isStringLiteral(arg) && primaryKeys.push(arg.text);
+      if (text.endsWith(".primaryKey")) {
+        for (const arg of node.arguments) {
+          if (ts.isStringLiteral(arg)) {
+            primaryKeys.push(arg.text);
+          }
+        }
+      }
       if (text.endsWith(".columns") && node.arguments.length === 1) {
         const obj = node.arguments[0];
-        if (ts.isObjectLiteralExpression(obj)) for (const prop of obj.properties) {
-          if (!ts.isPropertyAssignment(prop)) continue;
-          const colName = prop.name?.getText(sourceFile);
-          if (!colName) continue;
-          const initText = prop.initializer.getText(sourceFile),
-            colType = parseColumnType(initText);
-          columns[colName] = colType;
+        if (ts.isObjectLiteralExpression(obj)) {
+          for (const prop of obj.properties) {
+            if (!ts.isPropertyAssignment(prop)) continue;
+            const colName = prop.name?.getText(sourceFile);
+            if (!colName) continue;
+            const initText = prop.initializer.getText(sourceFile);
+            const colType = parseColumnType(initText);
+            columns[colName] = colType;
+          }
         }
       }
     }
@@ -214,7 +282,7 @@ function extractSchemaColumns(ts, sourceFile, columns, primaryKeys) {
   visit(sourceFile);
 }
 function tsTypeToValibot(ts, checker, type, seen) {
-  seen || (seen = /* @__PURE__ */new Set());
+  if (!seen) seen = /* @__PURE__ */new Set();
   const flags = type.getFlags();
   if (flags & (ts.TypeFlags.Object | ts.TypeFlags.Intersection)) {
     if (seen.has(type)) return "v.unknown()";
@@ -228,23 +296,38 @@ function tsTypeToValibot(ts, checker, type, seen) {
   if (flags & ts.TypeFlags.Null) return "v.null_()";
   if (flags & ts.TypeFlags.Any || flags & ts.TypeFlags.Unknown) return "v.unknown()";
   if (flags & ts.TypeFlags.Never) return "v.never()";
-  if (flags & ts.TypeFlags.StringLiteral) return `v.literal(${JSON.stringify(type.value)})`;
-  if (flags & ts.TypeFlags.NumberLiteral) return `v.literal(${type.value})`;
-  if (flags & ts.TypeFlags.BooleanLiteral) return `v.literal(${type.intrinsicName === "true"})`;
+  if (flags & ts.TypeFlags.StringLiteral) {
+    return `v.literal(${JSON.stringify(type.value)})`;
+  }
+  if (flags & ts.TypeFlags.NumberLiteral) {
+    return `v.literal(${type.value})`;
+  }
+  if (flags & ts.TypeFlags.BooleanLiteral) {
+    const name = type.intrinsicName;
+    return `v.literal(${name === "true"})`;
+  }
   if (type.isUnion()) {
-    const members = type.types,
-      hasNull = members.some(t => t.getFlags() & ts.TypeFlags.Null),
-      hasUndefined = members.some(t => t.getFlags() & (ts.TypeFlags.Undefined | ts.TypeFlags.Void)),
-      rest = members.filter(t => !(t.getFlags() & (ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Void)));
+    const members = type.types;
+    const hasNull = members.some(t => t.getFlags() & ts.TypeFlags.Null);
+    const hasUndefined = members.some(t => t.getFlags() & (ts.TypeFlags.Undefined | ts.TypeFlags.Void));
+    const rest = members.filter(t => !(t.getFlags() & (ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Void)));
     if (rest.length === 2 && rest.every(t => t.getFlags() & ts.TypeFlags.BooleanLiteral)) {
       let inner2 = "v.boolean()";
-      return hasNull && (inner2 = `v.nullable(${inner2})`), hasUndefined && (inner2 = `v.optional(${inner2})`), inner2;
+      if (hasNull) inner2 = `v.nullable(${inner2})`;
+      if (hasUndefined) inner2 = `v.optional(${inner2})`;
+      return inner2;
     }
     if (rest.length === 0) return "v.unknown()";
     let inner = rest.length === 1 ? recurse(rest[0]) : `v.union([${rest.map(t => recurse(t)).join(", ")}])`;
-    return hasNull && (inner = `v.nullable(${inner})`), hasUndefined && (inner = `v.optional(${inner})`), inner;
+    if (hasNull) inner = `v.nullable(${inner})`;
+    if (hasUndefined) inner = `v.optional(${inner})`;
+    return inner;
   }
-  const resolveSymbolType = prop => prop.valueDeclaration ? checker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration) : prop.declarations?.[0] ? checker.getTypeOfSymbolAtLocation(prop, prop.declarations[0]) : checker.getDeclaredTypeOfSymbol(prop);
+  const resolveSymbolType = prop => {
+    if (prop.valueDeclaration) return checker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration);
+    if (prop.declarations?.[0]) return checker.getTypeOfSymbolAtLocation(prop, prop.declarations[0]);
+    return checker.getDeclaredTypeOfSymbol(prop);
+  };
   if (type.isIntersection()) {
     const props2 = type.getProperties();
     if (props2.length === 0) return "v.object({})";
@@ -252,69 +335,98 @@ function tsTypeToValibot(ts, checker, type, seen) {
     for (const prop of props2) {
       const name = prop.getName();
       if (shouldSkipObjectKey(name)) continue;
-      const propType = resolveSymbolType(prop),
-        isOptional = !!(prop.getFlags() & ts.SymbolFlags.Optional);
+      const propType = resolveSymbolType(prop);
+      const isOptional = !!(prop.getFlags() & ts.SymbolFlags.Optional);
       let val = recurse(propType);
-      isOptional && !val.startsWith("v.optional(") && (val = `v.optional(${val})`), entries.push(`${formatObjectKey(name)}: ${val}`);
+      if (isOptional && !val.startsWith("v.optional(")) {
+        val = `v.optional(${val})`;
+      }
+      entries.push(`${formatObjectKey(name)}: ${val}`);
     }
-    return entries.length === 0 ? "v.object({})" : `v.object({
-    ${entries.join(`,
-    `)},
+    if (entries.length === 0) return "v.object({})";
+    return `v.object({
+    ${entries.join(",\n    ")},
   })`;
   }
   const props = type.getProperties();
   if (props.length > 0 && (type.getFlags() & ts.TypeFlags.Object || type.objectFlags)) {
     const objectFlags = type.objectFlags ?? 0;
     if (objectFlags & ts.ObjectFlags.Reference) {
-      const typeRef = type,
-        name = type.getSymbol()?.getName();
-      if ((name === "Array" || name === "ReadonlyArray") && typeRef.typeArguments?.length === 1) return `v.array(${recurse(typeRef.typeArguments[0])})`;
+      const typeRef = type;
+      const symbol = type.getSymbol();
+      const name = symbol?.getName();
+      if ((name === "Array" || name === "ReadonlyArray") && typeRef.typeArguments?.length === 1) {
+        return `v.array(${recurse(typeRef.typeArguments[0])})`;
+      }
+    }
+    if (objectFlags & ts.ObjectFlags.Tuple) {
+      const typeRef = type;
+      const typeArgs = typeRef.typeArguments || [];
+      return `v.tuple([${typeArgs.map(t => recurse(t)).join(", ")}])`;
     }
-    if (objectFlags & ts.ObjectFlags.Tuple) return `v.tuple([${(type.typeArguments || []).map(t => recurse(t)).join(", ")}])`;
     const entries = [];
     for (const prop of props) {
       const name = prop.getName();
       if (shouldSkipObjectKey(name)) continue;
-      const propType = resolveSymbolType(prop),
-        isOptional = !!(prop.getFlags() & ts.SymbolFlags.Optional);
+      const propType = resolveSymbolType(prop);
+      const isOptional = !!(prop.getFlags() & ts.SymbolFlags.Optional);
       let val = recurse(propType);
-      isOptional && !val.startsWith("v.optional(") && (val = `v.optional(${val})`), entries.push(`${formatObjectKey(name)}: ${val}`);
+      if (isOptional && !val.startsWith("v.optional(")) {
+        val = `v.optional(${val})`;
+      }
+      entries.push(`${formatObjectKey(name)}: ${val}`);
     }
-    return entries.length === 0 ? "v.object({})" : `v.object({
-    ${entries.join(`,
-    `)},
+    if (entries.length === 0) return "v.object({})";
+    return `v.object({
+    ${entries.join(",\n    ")},
   })`;
   }
   const stringIndex = type.getStringIndexType();
-  if (stringIndex) return `v.record(v.string(), ${recurse(stringIndex)})`;
+  if (stringIndex) {
+    return `v.record(v.string(), ${recurse(stringIndex)})`;
+  }
   const numberIndex = type.getNumberIndexType();
-  return numberIndex ? `v.record(v.number(), ${recurse(numberIndex)})` : "v.unknown()";
+  if (numberIndex) {
+    return `v.record(v.number(), ${recurse(numberIndex)})`;
+  }
+  return "v.unknown()";
 }
 function serializeColumnBuilder(col) {
-  let expr = `${col.type === "string" ? "string" : col.type === "number" ? "number" : col.type === "boolean" ? "boolean" : "json"}()`;
-  return col.serverName && (expr += `.from('${col.serverName}')`), col.optional && (expr += ".optional()"), expr;
+  const zeroType = col.type === "string" ? "string" : col.type === "number" ? "number" : col.type === "boolean" ? "boolean" : "json";
+  let expr = `${zeroType}()`;
+  if (col.serverName) {
+    expr += `.from('${col.serverName}')`;
+  }
+  if (col.optional) {
+    expr += ".optional()";
+  }
+  return expr;
 }
 function generateDrizzleSchemaFile(schema) {
-  const lines = ["// auto-generated by: on-zero generate (from drizzle schema)", "import { boolean, createSchema, json, number, relationships, string, table } from '@rocicorp/zero'", ""],
-    tableNames = Object.keys(schema.tables).sort();
+  const lines = [`// auto-generated by: on-zero generate (from drizzle schema)`, `import { boolean, createSchema, json, number, relationships, string, table } from '@rocicorp/zero'`, ``];
+  const tableNames = Object.keys(schema.tables).sort();
   for (const tableName of tableNames) {
-    const t = schema.tables[tableName],
-      colEntries = Object.entries(t.columns).map(([colName, col]) => `    ${colName}: ${serializeColumnBuilder(col)},`).join(`
-`),
-      pkArgs = t.primaryKey.map(k => `'${k}'`).join(", ");
-    lines.push(`const ${tableName}Table = table('${t.name}')`), lines.push("  .columns({"), lines.push(colEntries), lines.push("  })"), lines.push(`  .primaryKey(${pkArgs})`), lines.push("");
+    const t = schema.tables[tableName];
+    const colEntries = Object.entries(t.columns).map(([colName, col]) => `    ${colName}: ${serializeColumnBuilder(col)},`).join("\n");
+    const pkArgs = t.primaryKey.map(k => `'${k}'`).join(", ");
+    lines.push(`const ${tableName}Table = table('${t.name}')`);
+    lines.push(`  .columns({`);
+    lines.push(colEntries);
+    lines.push(`  })`);
+    lines.push(`  .primaryKey(${pkArgs})`);
+    lines.push(``);
   }
   const relTableNames = Object.keys(schema.relationships).sort();
   for (const tableName of relTableNames) {
-    const rels = schema.relationships[tableName],
-      relEntries = Object.entries(rels);
+    const rels = schema.relationships[tableName];
+    const relEntries = Object.entries(rels);
     if (relEntries.length === 0) continue;
     const relBody = relEntries.map(([relName, hops]) => {
       if (hops.length === 1) {
-        const hop = hops[0],
-          fn = hop.cardinality === "one" ? "one" : "many",
-          sf = hop.sourceField.map(f => `'${f}'`).join(", "),
-          df = hop.destField.map(f => `'${f}'`).join(", ");
+        const hop = hops[0];
+        const fn = hop.cardinality === "one" ? "one" : "many";
+        const sf = hop.sourceField.map(f => `'${f}'`).join(", ");
+        const df = hop.destField.map(f => `'${f}'`).join(", ");
         return `    ${relName}: ${fn}({
       sourceField: [${sf}],
       destSchema: ${hop.destSchema}Table,
@@ -322,61 +434,73 @@ function generateDrizzleSchemaFile(schema) {
     })`;
       }
       const hopCode = hops.map(hop => {
-        const fn = hop.cardinality === "one" ? "one" : "many",
-          sf = hop.sourceField.map(f => `'${f}'`).join(", "),
-          df = hop.destField.map(f => `'${f}'`).join(", ");
+        const fn = hop.cardinality === "one" ? "one" : "many";
+        const sf = hop.sourceField.map(f => `'${f}'`).join(", ");
+        const df = hop.destField.map(f => `'${f}'`).join(", ");
         return `${fn}({ sourceField: [${sf}], destSchema: ${hop.destSchema}Table, destField: [${df}] })`;
       }).join(", ");
       return `    ${relName}: [${hopCode}]`;
-    }).join(`,
-`);
-    lines.push(`const ${tableName}Relationships = relationships(${tableName}Table, ({ one, many }) => ({`), lines.push(relBody), lines.push("}))"), lines.push("");
-  }
-  const tableList = tableNames.map(n => `  ${n}Table,`).join(`
-`),
-    relList = relTableNames.filter(n => Object.keys(schema.relationships[n]).length > 0).map(n => `  ${n}Relationships,`).join(`
-`);
-  return lines.push("export const schema = createSchema({"), lines.push("  tables: ["), lines.push(tableList), lines.push("  ],"), lines.push("  relationships: ["), lines.push(relList), lines.push("  ],"), lines.push("})"), lines.push(""), lines.join(`
-`);
+    }).join(",\n");
+    lines.push(`const ${tableName}Relationships = relationships(${tableName}Table, ({ one, many }) => ({`);
+    lines.push(relBody);
+    lines.push(`}))`);
+    lines.push(``);
+  }
+  const tableList = tableNames.map(n => `  ${n}Table,`).join("\n");
+  const relList = relTableNames.filter(n => Object.keys(schema.relationships[n]).length > 0).map(n => `  ${n}Relationships,`).join("\n");
+  lines.push(`export const schema = createSchema({`);
+  lines.push(`  tables: [`);
+  lines.push(tableList);
+  lines.push(`  ],`);
+  lines.push(`  relationships: [`);
+  lines.push(relList);
+  lines.push(`  ],`);
+  lines.push(`})`);
+  lines.push(``);
+  return lines.join("\n");
 }
 async function generate(options) {
   const {
-      dir,
-      after,
-      silent
-    } = options,
-    baseDir = resolve(dir),
-    mutationsDir = resolve(baseDir, "mutations"),
-    usesMutationsDir = existsSync(mutationsDir),
-    modelsDir = usesMutationsDir ? mutationsDir : resolve(baseDir, "models"),
-    modelsDirName = usesMutationsDir ? "mutations" : "models",
-    generatedDir = resolve(baseDir, "generated"),
-    queriesDir = resolve(baseDir, "queries");
-  existsSync(generatedDir) || mkdirSync(generatedDir, {
-    recursive: !0
-  }), loadCache();
-  const allModelFiles = readdirSync(modelsDir).filter(f => f.endsWith(".ts")).sort(),
-    filesWithSchema = allModelFiles.filter(f => readFileSync(resolve(modelsDir, f), "utf-8").includes("export const schema = table(")),
-    allModelNames = allModelFiles.map(f => basename(f, ".ts")),
-    schemaModelNames = filesWithSchema.map(f => basename(f, ".ts"));
-  let filesChanged = [writeFileIfChanged(resolve(generatedDir, "models.ts"), generateModelsFile(allModelNames, modelsDirName)),
-    // only generate types.ts and tables.ts when model files define schemas.
-    // when using drizzle-zero CLI for schema generation, these files are
-    // managed externally and should not be overwritten.
-    ...(filesWithSchema.length > 0 ? [writeFileIfChanged(resolve(generatedDir, "types.ts"), generateTypesFile(schemaModelNames)), writeFileIfChanged(resolve(generatedDir, "tables.ts"), generateTablesFile(schemaModelNames, modelsDirName))] : []), writeFileIfChanged(resolve(generatedDir, "README.md"), generateReadmeFile())].filter(Boolean).length,
-    queryCount = 0,
-    mutationCount = 0;
-  const ts = await import("typescript"),
-    typeToValibot = paramType => {
-      try {
-        return parseTypeString(paramType.trim());
-      } catch {
-        return null;
-      }
-    };
+    dir,
+    after,
+    silent
+  } = options;
+  const baseDir = resolve(dir);
+  const mutationsDir = resolve(baseDir, "mutations");
+  const usesMutationsDir = existsSync(mutationsDir);
+  const modelsDir = usesMutationsDir ? mutationsDir : resolve(baseDir, "models");
+  const modelsDirName = usesMutationsDir ? "mutations" : "models";
+  const generatedDir = resolve(baseDir, "generated");
+  const queriesDir = resolve(baseDir, "queries");
+  if (!existsSync(generatedDir)) {
+    mkdirSync(generatedDir, {
+      recursive: true
+    });
+  }
+  loadCache();
+  const allModelFiles = readdirSync(modelsDir).filter(f => f.endsWith(".ts")).sort();
+  const filesWithSchema = allModelFiles.filter(f => readFileSync(resolve(modelsDir, f), "utf-8").includes("export const schema = table("));
+  const allModelNames = allModelFiles.map(f => basename(f, ".ts"));
+  const schemaModelNames = filesWithSchema.map(f => basename(f, ".ts"));
+  const writeResults = [writeFileIfChanged(resolve(generatedDir, "models.ts"), generateModelsFile(allModelNames, modelsDirName)),
+  // only generate types.ts and tables.ts when model files define schemas.
+  // when using drizzle-zero CLI for schema generation, these files are
+  // managed externally and should not be overwritten.
+  ...(filesWithSchema.length > 0 ? [writeFileIfChanged(resolve(generatedDir, "types.ts"), generateTypesFile(schemaModelNames)), writeFileIfChanged(resolve(generatedDir, "tables.ts"), generateTablesFile(schemaModelNames, modelsDirName))] : []), writeFileIfChanged(resolve(generatedDir, "README.md"), generateReadmeFile())];
+  let filesChanged = writeResults.filter(Boolean).length;
+  let queryCount = 0;
+  let mutationCount = 0;
+  const ts = await import("typescript");
+  const typeToValibot = paramType => {
+    try {
+      return parseTypeString(paramType.trim());
+    } catch {
+      return null;
+    }
+  };
   if (existsSync(queriesDir)) {
-    const queryFiles = readdirSync(queriesDir).filter(f => f.endsWith(".ts")),
-      allQueries = [];
+    const queryFiles = readdirSync(queriesDir).filter(f => f.endsWith(".ts"));
+    const allQueries = [];
     let queryResolver = null;
     const getQueryResolver = () => {
       if (!queryResolver) {
@@ -389,14 +513,15 @@ async function generate(options) {
       return queryResolver;
     };
     for (const file of queryFiles) {
-      const filePath = resolve(queriesDir, file),
-        fileBaseName = basename(file, ".ts");
+      const filePath = resolve(queriesDir, file);
+      const fileBaseName = basename(file, ".ts");
       try {
-        const content = readFileSync(filePath, "utf-8"),
-          sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, !0);
+        const content = readFileSync(filePath, "utf-8");
+        const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
         ts.forEachChild(sourceFile, node => {
           if (ts.isVariableStatement(node)) {
-            if (!node.modifiers?.find(m => m.kind === ts.SyntaxKind.ExportKeyword)) return;
+            const exportModifier = node.modifiers?.find(m => m.kind === ts.SyntaxKind.ExportKeyword);
+            if (!exportModifier) return;
             const declaration = node.declarationList.declarations[0];
             if (!declaration || !ts.isVariableDeclaration(declaration)) return;
             const name = declaration.name.getText(sourceFile);
@@ -404,40 +529,50 @@ async function generate(options) {
             if (declaration.initializer && ts.isArrowFunction(declaration.initializer)) {
               const params = declaration.initializer.parameters;
               let paramType = "void";
-              params.length > 0 && (paramType = params[0].type?.getText(sourceFile) || "unknown");
+              if (params.length > 0) {
+                const param = params[0];
+                paramType = param.type?.getText(sourceFile) || "unknown";
+              }
               let valibotCode = typeToValibot(paramType);
               if (!valibotCode && params.length > 0 && params[0].type) {
-                const resolver = getQueryResolver(),
-                  resolverSourceFile = resolver.program.getSourceFile(filePath);
+                const resolver = getQueryResolver();
+                const resolverSourceFile = resolver.program.getSourceFile(filePath);
                 if (resolverSourceFile) {
                   const resolvedType = resolveParamType(ts, resolver, resolverSourceFile, name, 0);
-                  resolvedType && (valibotCode = resolver.typeToValibot(resolvedType));
+                  if (resolvedType) {
+                    valibotCode = resolver.typeToValibot(resolvedType);
+                  }
                 }
               }
-              valibotCode ? allQueries.push({
-                name,
-                params: paramType,
-                valibotCode,
-                sourceFile: fileBaseName
-              }) : !silent && paramType !== "void" && console.error(`\u2717 ${name}: could not resolve type "${paramType}"`);
+              if (valibotCode) {
+                allQueries.push({
+                  name,
+                  params: paramType,
+                  valibotCode,
+                  sourceFile: fileBaseName
+                });
+              } else if (!silent && paramType !== "void") {
+                console.error(`\u2717 ${name}: could not resolve type "${paramType}"`);
+              }
             }
           }
         });
       } catch (err) {
-        silent || console.error(`Error processing ${file}:`, err);
+        if (!silent) console.error(`Error processing ${file}:`, err);
       }
     }
     queryCount = allQueries.length;
-    const groupedChanged = writeFileIfChanged(resolve(generatedDir, "groupedQueries.ts"), generateGroupedQueriesFile(allQueries)),
-      syncedChanged = writeFileIfChanged(resolve(generatedDir, "syncedQueries.ts"), generateSyncedQueriesFile(allQueries));
-    groupedChanged && filesChanged++, syncedChanged && filesChanged++;
+    const groupedChanged = writeFileIfChanged(resolve(generatedDir, "groupedQueries.ts"), generateGroupedQueriesFile(allQueries));
+    const syncedChanged = writeFileIfChanged(resolve(generatedDir, "syncedQueries.ts"), generateSyncedQueriesFile(allQueries));
+    if (groupedChanged) filesChanged++;
+    if (syncedChanged) filesChanged++;
   }
-  const allModelMutations = [],
-    mutationFiles = [],
-    unresolvedModels = [];
+  const allModelMutations = [];
+  const mutationFiles = [];
+  const unresolvedModels = [];
   for (const file of allModelFiles) {
-    const filePath = resolve(modelsDir, file),
-      fileBaseName = basename(file, ".ts");
+    const filePath = resolve(modelsDir, file);
+    const fileBaseName = basename(file, ".ts");
     try {
       const content = readFileSync(filePath, "utf-8");
       mutationFiles.push({
@@ -445,32 +580,43 @@ async function generate(options) {
         content,
         baseName: fileBaseName
       });
-      const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, !0),
-        result = extractMutationsFromModel(ts, sourceFile, content, filePath, !!silent, typeToValibot);
-      result && (result.modelName = fileBaseName, allModelMutations.push(result), result.custom.some(m => m.paramType !== "void" && m.paramType !== "unknown" && !m.valibotCode) && unresolvedModels.push({
-        baseName: fileBaseName,
-        filePath
-      }));
+      const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+      const result = extractMutationsFromModel(ts, sourceFile, content, filePath, !!silent, typeToValibot);
+      if (result) {
+        result.modelName = fileBaseName;
+        allModelMutations.push(result);
+        const hasUnresolved = result.custom.some(m => m.paramType !== "void" && m.paramType !== "unknown" && !m.valibotCode);
+        if (hasUnresolved) {
+          unresolvedModels.push({
+            baseName: fileBaseName,
+            filePath
+          });
+        }
+      }
     } catch (err) {
-      silent || console.error(`Error extracting mutations from ${file}:`, err);
+      if (!silent) console.error(`Error extracting mutations from ${file}:`, err);
     }
   }
   if (unresolvedModels.length > 0) {
     const collectTsFiles = dir2 => {
-        const results = [];
-        for (const entry of readdirSync(dir2, {
-          withFileTypes: !0
-        })) {
-          const fullPath = resolve(dir2, entry.name);
-          entry.isDirectory() && entry.name !== "node_modules" ? results.push(...collectTsFiles(fullPath)) : entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts") && results.push({
+      const results = [];
+      for (const entry of readdirSync(dir2, {
+        withFileTypes: true
+      })) {
+        const fullPath = resolve(dir2, entry.name);
+        if (entry.isDirectory() && entry.name !== "node_modules") {
+          results.push(...collectTsFiles(fullPath));
+        } else if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
+          results.push({
             path: fullPath,
             content: readFileSync(fullPath, "utf-8")
           });
         }
-        return results;
-      },
-      allFiles = collectTsFiles(baseDir),
-      modelResolver = createTypeResolver(ts, allFiles, baseDir);
+      }
+      return results;
+    };
+    const allFiles = collectTsFiles(baseDir);
+    const modelResolver = createTypeResolver(ts, allFiles, baseDir);
     for (const {
       baseName,
       filePath
@@ -479,18 +625,28 @@ async function generate(options) {
       if (!resolverSourceFile) continue;
       const resolvedTypes = resolveMutationParamTypes(ts, modelResolver, resolverSourceFile);
       if (resolvedTypes.size === 0) continue;
-      const content = readFileSync(filePath, "utf-8"),
-        sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, !0),
-        result = extractMutationsFromModel(ts, sourceFile, content, filePath, !!silent, typeToValibot, resolvedTypes, modelResolver.typeToValibot);
+      const content = readFileSync(filePath, "utf-8");
+      const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+      const result = extractMutationsFromModel(ts, sourceFile, content, filePath, !!silent, typeToValibot, resolvedTypes, modelResolver.typeToValibot);
       if (result) {
         result.modelName = baseName;
         const idx = allModelMutations.findIndex(m => m.modelName === baseName);
-        idx >= 0 && (allModelMutations[idx] = result);
+        if (idx >= 0) allModelMutations[idx] = result;
       }
     }
   }
-  for (const model of allModelMutations) model.hasCRUD && (mutationCount += 3), mutationCount += model.custom.filter(m => !model.hasCRUD || !["insert", "update", "delete", "upsert"].includes(m.name)).length;
-  if (allModelMutations.length > 0 && writeFileIfChanged(resolve(generatedDir, "syncedMutations.ts"), generateSyncedMutationsFile(allModelMutations)) && filesChanged++, filesChanged > 0 && !silent && console.info(`\u2713 ${allModelFiles.length} models (${filesWithSchema.length} schemas)${queryCount ? `, ${queryCount} queries` : ""}${mutationCount ? `, ${mutationCount} mutations` : ""}`), filesChanged > 0 && after) {
+  for (const model of allModelMutations) {
+    if (model.hasCRUD) mutationCount += 3;
+    mutationCount += model.custom.filter(m => !model.hasCRUD || !["insert", "update", "delete", "upsert"].includes(m.name)).length;
+  }
+  if (allModelMutations.length > 0) {
+    const mutationsChanged = writeFileIfChanged(resolve(generatedDir, "syncedMutations.ts"), generateSyncedMutationsFile(allModelMutations));
+    if (mutationsChanged) filesChanged++;
+  }
+  if (filesChanged > 0 && !silent) {
+    console.info(`\u2713 ${allModelFiles.length} models (${filesWithSchema.length} schemas)${queryCount ? `, ${queryCount} queries` : ""}${mutationCount ? `, ${mutationCount} mutations` : ""}`);
+  }
+  if (filesChanged > 0 && after) {
     const {
       execSync
     } = await import("node:child_process");
@@ -503,10 +659,11 @@ async function generate(options) {
         }
       });
     } catch (err) {
-      silent || console.error(`Error running after command: ${err}`);
+      if (!silent) console.error(`Error running after command: ${err}`);
     }
   }
-  return saveCache(), {
+  saveCache();
+  return {
     filesChanged,
     modelCount: allModelFiles.length,
     schemaCount: filesWithSchema.length,
@@ -516,36 +673,41 @@ async function generate(options) {
 }
 async function watch(options) {
   const {
-      dir,
-      debounce = 1e3
-    } = options,
-    baseDir = resolve(dir),
-    mutationsDir = resolve(baseDir, "mutations"),
-    modelsDir = existsSync(mutationsDir) ? mutationsDir : resolve(baseDir, "models"),
-    queriesDir = resolve(baseDir, "queries"),
-    generatedDir = resolve(baseDir, "generated");
+    dir,
+    debounce = 1e3
+  } = options;
+  const baseDir = resolve(dir);
+  const mutationsDir = resolve(baseDir, "mutations");
+  const modelsDir = existsSync(mutationsDir) ? mutationsDir : resolve(baseDir, "models");
+  const queriesDir = resolve(baseDir, "queries");
+  const generatedDir = resolve(baseDir, "generated");
   await generate({
     ...options,
-    silent: !0
-  }), console.info(`\u{1F440} watching...
-`);
+    silent: true
+  });
+  console.info("\u{1F440} watching...\n");
   const chokidar = await import("chokidar");
   let debounceTimer = null;
   const debouncedRegenerate = (path, event) => {
-      debounceTimer && clearTimeout(debounceTimer), console.info(`
-${event} ${path}`), debounceTimer = setTimeout(() => {
-        generate({
-          ...options,
-          silent: !1
-        });
-      }, debounce);
-    },
-    watcher = chokidar.watch([modelsDir, queriesDir], {
-      persistent: !0,
-      ignoreInitial: !0,
-      ignored: [generatedDir]
-    });
-  return watcher.on("change", path => debouncedRegenerate(path, "\u{1F4DD}")), watcher.on("add", path => debouncedRegenerate(path, "\u2795")), watcher.on("unlink", path => debouncedRegenerate(path, "\u{1F5D1}\uFE0F ")), watcher;
+    if (debounceTimer) clearTimeout(debounceTimer);
+    console.info(`
+${event} ${path}`);
+    debounceTimer = setTimeout(() => {
+      generate({
+        ...options,
+        silent: false
+      });
+    }, debounce);
+  };
+  const watcher = chokidar.watch([modelsDir, queriesDir], {
+    persistent: true,
+    ignoreInitial: true,
+    ignored: [generatedDir]
+  });
+  watcher.on("change", path => debouncedRegenerate(path, "\u{1F4DD}"));
+  watcher.on("add", path => debouncedRegenerate(path, "\u2795"));
+  watcher.on("unlink", path => debouncedRegenerate(path, "\u{1F5D1}\uFE0F "));
+  return watcher;
 }
 export { generate, generateDrizzleSchemaFile, watch };
 //# sourceMappingURL=generate.mjs.map