on-zero 0.1.39 → 0.1.41

package/dist/esm/generate.mjs

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
-import { basename, resolve } from "node:path";
+import { basename, dirname, resolve } from "node:path";
 const hash = s => createHash("sha256").update(s).digest("hex");
 let generateCache = {},
   generateCachePath = "";
@@ -90,6 +90,7 @@ this folder is auto-generated by on-zero. do not edit files here directly.
 - \`tables.ts\` - exports table schemas for type inference
 - \`groupedQueries.ts\` - namespaced query re-exports for client setup
 - \`syncedQueries.ts\` - namespaced syncedQuery wrappers for server setup
+- \`syncedMutations.ts\` - valibot validators for mutation args (server auto-validation)
 
 ## usage guidelines
 
@@ -161,22 +162,7 @@ import * as Queries from './groupedQueries'
 `,
     namespaceDefs = sortedFiles.map(file => {
       const queryDefs = queryByFile.get(file).sort((a, b) => a.name.localeCompare(b.name)).map(q => {
-        const lines = q.valibotCode.split(`
-`).filter(l => l.trim()),
-          schemaLineIndex = lines.findIndex(l => l.startsWith("export const QueryParams"));
-        let validatorDef = "";
-        if (schemaLineIndex !== -1) {
-          const schemaLines = [];
-          let openBraces = 0,
-            started = !1;
-          for (let i = schemaLineIndex; i < lines.length; i++) {
-            const line = lines[i],
-              cleaned = started ? line : line.replace("export const QueryParams = ", "");
-            if (schemaLines.push(cleaned), started = !0, openBraces += (cleaned.match(/\{/g) || []).length, openBraces -= (cleaned.match(/\}/g) || []).length, openBraces += (cleaned.match(/\(/g) || []).length, openBraces -= (cleaned.match(/\)/g) || []).length, openBraces === 0 && schemaLines.length > 0) break;
-          }
-          validatorDef = schemaLines.join(`
-`);
-        }
+        const validatorDef = q.valibotCode.trim();
         if (q.params === "void" || !validatorDef) return `  ${q.name}: defineQuery(() => Queries.${file}.${q.name}()),`;
         const indentedValidator = validatorDef.split(`
 `).map((line, i) => i === 0 ? line : `    ${line}`).join(`
@@ -203,6 +189,364 @@ ${queriesObject}
 })
 `;
 }
+function createTypeResolver(ts, files, dir) {
+  const configPath = ts.findConfigFile(dir, ts.sys.fileExists, "tsconfig.json");
+  let compilerOptions = {
+    target: ts.ScriptTarget.Latest,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
+    strict: !1,
+    skipLibCheck: !0,
+    noEmit: !0
+  };
+  if (configPath) {
+    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+    if (configFile.config) {
+      const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, dirname(configPath));
+      compilerOptions = {
+        ...compilerOptions,
+        ...parsed.options
+      };
+    }
+  }
+  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);
+  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();
+  return {
+    program,
+    checker,
+    // resolve a type annotation node to a ts.Type
+    resolveType(node) {
+      try {
+        return checker.getTypeFromTypeNode(node);
+      } catch {
+        return null;
+      }
+    },
+    // convert a resolved type to valibot code
+    typeToValibot(type) {
+      return tsTypeToValibot(ts, checker, type);
+    }
+  };
+}
+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;
+    const decl = node.declarationList.declarations[0];
+    if (!(!decl || !ts.isVariableDeclaration(decl)) && decl.name.getText(sourceFile) === exportName && decl.initializer && ts.isArrowFunction(decl.initializer)) {
+      const param = decl.initializer.parameters[paramIndex];
+      param?.type && (result = resolver.resolveType(param.type));
+    }
+  }), 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;
+    const decl = node.declarationList.declarations[0];
+    if (!decl || !ts.isVariableDeclaration(decl) || decl.name.getText(sourceFile) !== "mutate" || !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;
+    }
+    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 || params.length < 2) continue;
+      const typeNode = params[1].type;
+      if (!typeNode) continue;
+      const expanded = resolver.resolveType(typeNode);
+      expanded && resolved.set(name, expanded);
+    }
+  }), 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;
+    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 null;
+  const args = mutateNode.arguments,
+    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);
+  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") {
+      custom.push({
+        name,
+        paramType: "unknown",
+        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: "",
+    hasCRUD,
+    columns,
+    primaryKeys,
+    custom
+  };
+}
+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(".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;
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+}
+function parseColumnType(initText) {
+  const optional = initText.includes(".optional()");
+  let type = "string";
+  return initText.startsWith("number(") ? type = "number" : initText.startsWith("boolean(") ? type = "boolean" : initText.startsWith("json(") || initText.startsWith("json<") ? type = "json" : initText.startsWith("enumeration(") && (type = "enum"), {
+    type,
+    optional
+  };
+}
+function columnTypeToValibot(col) {
+  let base;
+  switch (col.type) {
+    case "string":
+      base = "v.string()";
+      break;
+    case "number":
+      base = "v.number()";
+      break;
+    case "boolean":
+      base = "v.boolean()";
+      break;
+    case "json":
+      base = "v.unknown()";
+      break;
+    case "enum":
+      base = "v.string()";
+      break;
+    default:
+      base = "v.unknown()";
+  }
+  return col.optional ? `v.optional(v.nullable(${base}))` : base;
+}
+function schemaColumnsToValibot(columns, primaryKeys, mode) {
+  const entries = [];
+  if (mode === "delete") for (const pk of primaryKeys) {
+    const col = columns[pk];
+    col && entries.push(`${pk}: ${columnTypeToValibot({
+      ...col,
+      optional: !1
+    })}`);
+  } else if (mode === "update") for (const [name, col] of Object.entries(columns)) primaryKeys.includes(name) ? entries.push(`${name}: ${columnTypeToValibot({
+    ...col,
+    optional: !1
+  })}`) : entries.push(`${name}: ${columnTypeToValibot({
+    ...col,
+    optional: !0
+  })}`);else for (const [name, col] of Object.entries(columns)) entries.push(`${name}: ${columnTypeToValibot(col)}`);
+  return `v.object({
+    ${entries.join(`,
+    `)},
+  })`;
+}
+function generateSyncedMutationsFile(modelMutations) {
+  return `// auto-generated by: on-zero generate
+// mutation validators derived from model schemas and handler types
+import * as v from 'valibot'
+
+export const mutationValidators = {
+${[...modelMutations].sort((a, b) => a.modelName.localeCompare(b.modelName)).map(model => {
+    const entries = [];
+    if (model.hasCRUD && Object.keys(model.columns).length > 0) for (const mode of ["insert", "update", "delete"]) if (model.custom.some(m => m.name === mode)) {
+      const customMut = model.custom.find(m => m.name === mode);
+      customMut.valibotCode ? entries.push(`    ${mode}: ${extractValibotExpression(customMut.valibotCode)},`) : entries.push(`    ${mode}: ${schemaColumnsToValibot(model.columns, model.primaryKeys, mode)},`);
+    } else entries.push(`    ${mode}: ${schemaColumnsToValibot(model.columns, model.primaryKeys, mode)},`);
+    for (const mut of model.custom) if (!(model.hasCRUD && ["insert", "update", "delete", "upsert"].includes(mut.name))) {
+      if (mut.paramType === "void" || !mut.valibotCode) {
+        entries.push(`    ${mut.name}: v.void_(),`);
+        continue;
+      }
+      entries.push(`    ${mut.name}: ${extractValibotExpression(mut.valibotCode)},`);
+    }
+    return `  ${model.modelName}: {
+${entries.join(`
+`)}
+  },`;
+  }).join(`
+`)}
+}
+`;
+}
+function extractValibotExpression(valibotCode) {
+  return valibotCode.trim() || "v.unknown()";
+}
+function parseTypeString(type) {
+  if (type = type.trim(), type === "string") return "v.string()";
+  if (type === "number") return "v.number()";
+  if (type === "boolean") return "v.boolean()";
+  if (type === "void" || type === "undefined") return "v.void_()";
+  if (type === "null") return "v.null_()";
+  if (type === "any" || type === "unknown") return "v.unknown()";
+  if (type.startsWith("{") && type.endsWith("}")) {
+    const inner = type.slice(1, -1).trim();
+    if (!inner) return "v.object({})";
+    const normalized = inner.replace(/\n/g, "; ").replace(/;\s*;/g, ";"),
+      entries = [];
+    for (const part of normalized.split(";")) {
+      const trimmed = part.trim().replace(/,\s*$/, "");
+      if (!trimmed) continue;
+      const match = trimmed.match(/^(?:readonly\s+)?(\w+)(\?)?:\s*(.+)$/);
+      if (!match) continue;
+      const [, name, opt, typeStr] = match,
+        parsed = parseTypeString(typeStr.trim());
+      if (!parsed) return null;
+      let val = parsed;
+      opt && (val = `v.optional(${val})`), entries.push(`${name}: ${val}`);
+    }
+    return entries.length === 0 ? "v.object({})" : `v.object({
+    ${entries.join(`,
+    `)},
+  })`;
+  }
+  if (type.endsWith("[]")) {
+    const inner = parseTypeString(type.slice(0, -2).trim());
+    return inner ? `v.array(${inner})` : null;
+  }
+  return null;
+}
+function tsTypeToValibot(ts, checker, type, seen) {
+  seen || (seen = /* @__PURE__ */new Set());
+  const flags = type.getFlags();
+  if (flags & (ts.TypeFlags.Object | ts.TypeFlags.Intersection)) {
+    if (seen.has(type)) return "v.unknown()";
+    seen.add(type);
+  }
+  const recurse = t => tsTypeToValibot(ts, checker, t, seen);
+  if (flags & ts.TypeFlags.String) return "v.string()";
+  if (flags & ts.TypeFlags.Number) return "v.number()";
+  if (flags & ts.TypeFlags.Boolean) return "v.boolean()";
+  if (flags & ts.TypeFlags.Void || flags & ts.TypeFlags.Undefined) return "v.void_()";
+  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 (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)));
+    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 (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;
+  }
+  const resolveSymbolType = prop => prop.valueDeclaration ? checker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration) : prop.declarations?.[0] ? checker.getTypeOfSymbolAtLocation(prop, prop.declarations[0]) : checker.getDeclaredTypeOfSymbol(prop);
+  if (type.isIntersection()) {
+    const props2 = type.getProperties();
+    if (props2.length === 0) return "v.object({})";
+    const entries = [];
+    for (const prop of props2) {
+      const propType = resolveSymbolType(prop),
+        isOptional = !!(prop.getFlags() & ts.SymbolFlags.Optional);
+      let val = recurse(propType);
+      isOptional && !val.startsWith("v.optional(") && (val = `v.optional(${val})`), entries.push(`${prop.getName()}: ${val}`);
+    }
+    return `v.object({
+    ${entries.join(`,
+    `)},
+  })`;
+  }
+  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])})`;
+    }
+    if (objectFlags & ts.ObjectFlags.Tuple) return `v.tuple([${(type.typeArguments || []).map(t => recurse(t)).join(", ")}])`;
+    const entries = [];
+    for (const prop of props) {
+      const propType = resolveSymbolType(prop),
+        isOptional = !!(prop.getFlags() & ts.SymbolFlags.Optional);
+      let val = recurse(propType);
+      isOptional && !val.startsWith("v.optional(") && (val = `v.optional(${val})`), entries.push(`${prop.getName()}: ${val}`);
+    }
+    return entries.length === 0 ? "v.object({})" : `v.object({
+    ${entries.join(`,
+    `)},
+  })`;
+  }
+  const stringIndex = type.getStringIndexType();
+  if (stringIndex) return `v.record(v.string(), ${recurse(stringIndex)})`;
+  const numberIndex = type.getNumberIndexType();
+  return numberIndex ? `v.record(v.number(), ${recurse(numberIndex)})` : "v.unknown()";
+}
 async function generate(options) {
   const {
       dir,
@@ -219,17 +563,30 @@ async function generate(options) {
   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("));
   let filesChanged = [writeFileIfChanged(resolve(generatedDir, "models.ts"), generateModelsFile(allModelFiles)), writeFileIfChanged(resolve(generatedDir, "types.ts"), generateTypesFile(filesWithSchema)), writeFileIfChanged(resolve(generatedDir, "tables.ts"), generateTablesFile(filesWithSchema)), writeFileIfChanged(resolve(generatedDir, "README.md"), generateReadmeFile())].filter(Boolean).length,
-    queryCount = 0;
+    queryCount = 0,
+    mutationCount = 0;
+  const ts = await import("typescript"),
+    typeToValibot = paramType => {
+      try {
+        return parseTypeString(paramType.trim());
+      } catch {
+        return null;
+      }
+    };
   if (existsSync(queriesDir)) {
-    const ts = await import("typescript"),
-      {
-        ModelToValibot
-      } = await import("@sinclair/typebox-codegen/model/index.js"),
-      {
-        TypeScriptToModel
-      } = await import("@sinclair/typebox-codegen/typescript/index.js"),
-      queryFiles = readdirSync(queriesDir).filter(f => f.endsWith(".ts")),
+    const queryFiles = readdirSync(queriesDir).filter(f => f.endsWith(".ts")),
       allQueries = [];
+    let queryResolver = null;
+    const getQueryResolver = () => {
+      if (!queryResolver) {
+        const allFiles = readdirSync(queriesDir).filter(f => f.endsWith(".ts")).map(f => ({
+          path: resolve(queriesDir, f),
+          content: readFileSync(resolve(queriesDir, f), "utf-8")
+        }));
+        queryResolver = createTypeResolver(ts, allFiles, queriesDir);
+      }
+      return queryResolver;
+    };
     for (const file of queryFiles) {
       const filePath = resolve(queriesDir, file),
         fileBaseName = basename(file, ".ts");
@@ -247,19 +604,21 @@ async function generate(options) {
               const params = declaration.initializer.parameters;
               let paramType = "void";
               params.length > 0 && (paramType = params[0].type?.getText(sourceFile) || "unknown");
-              try {
-                const typeString = `type QueryParams = ${paramType}`,
-                  model = TypeScriptToModel.Generate(typeString),
-                  valibotCode = ModelToValibot.Generate(model);
-                allQueries.push({
-                  name,
-                  params: paramType,
-                  valibotCode,
-                  sourceFile: fileBaseName
-                });
-              } catch (err) {
-                silent || console.error(`\u2717 ${name}: ${err}`);
+              let valibotCode = typeToValibot(paramType);
+              if (!valibotCode && params.length > 0 && params[0].type) {
+                const resolver = getQueryResolver(),
+                  resolverSourceFile = resolver.program.getSourceFile(filePath);
+                if (resolverSourceFile) {
+                  const resolvedType = resolveParamType(ts, resolver, resolverSourceFile, name, 0);
+                  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}"`);
             }
           }
         });
@@ -272,7 +631,66 @@ async function generate(options) {
       syncedChanged = writeFileIfChanged(resolve(generatedDir, "syncedQueries.ts"), generateSyncedQueriesFile(allQueries));
     groupedChanged && filesChanged++, syncedChanged && filesChanged++;
   }
-  if (filesChanged > 0 && !silent && console.info(`\u2713 ${allModelFiles.length} models (${filesWithSchema.length} schemas)${queryCount ? `, ${queryCount} queries` : ""}`), filesChanged > 0 && after) {
+  const allModelMutations = [],
+    mutationFiles = [],
+    unresolvedModels = [];
+  for (const file of allModelFiles) {
+    const filePath = resolve(modelsDir, file),
+      fileBaseName = basename(file, ".ts");
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      if (!content.includes("export const mutate")) continue;
+      mutationFiles.push({
+        path: filePath,
+        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
+      }));
+    } catch (err) {
+      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({
+            path: fullPath,
+            content: readFileSync(fullPath, "utf-8")
+          });
+        }
+        return results;
+      },
+      allFiles = collectTsFiles(baseDir),
+      modelResolver = createTypeResolver(ts, allFiles, baseDir);
+    for (const {
+      baseName,
+      filePath
+    } of unresolvedModels) {
+      const resolverSourceFile = modelResolver.program.getSourceFile(filePath);
+      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);
+      if (result) {
+        result.modelName = baseName;
+        const idx = allModelMutations.findIndex(m => m.modelName === baseName);
+        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) {
     const {
       execSync
     } = await import("node:child_process");
@@ -292,7 +710,8 @@ async function generate(options) {
     filesChanged,
     modelCount: allModelFiles.length,
     schemaCount: filesWithSchema.length,
-    queryCount
+    queryCount,
+    mutationCount
   };
 }
 async function watch(options) {