on-zero 0.1.39 → 0.1.41

package/dist/cjs/generate.native.js

@@ -154,6 +154,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
 
@@ -250,27 +251,11 @@ import * as Queries from './groupedQueries'
           return a.name.localeCompare(b.name);
         }),
         queryDefs = fileQueries.map(function (q2) {
-          var lines = q2.valibotCode.split(`
-`).filter(function (l) {
-              return l.trim();
-            }),
-            schemaLineIndex = lines.findIndex(function (l) {
-              return l.startsWith("export const QueryParams");
-            }),
-            validatorDef = "";
-          if (schemaLineIndex !== -1) {
-            for (var schemaLines = [], openBraces = 0, started = !1, i = schemaLineIndex; i < lines.length; i++) {
-              var 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(`
-`);
-          }
+          var validatorDef = q2.valibotCode.trim();
           if (q2.params === "void" || !validatorDef) return `  ${q2.name}: defineQuery(() => Queries.${file}.${q2.name}()),`;
           var indentedValidator = validatorDef.split(`
-`).map(function (line2, i2) {
-            return i2 === 0 ? line2 : `    ${line2}`;
+`).map(function (line, i) {
+            return i === 0 ? line : `    ${line}`;
           }).join(`
 `);
           return `  ${q2.name}: defineQuery(
@@ -297,6 +282,631 @@ ${queriesObject}
 })
 `;
 }
+function createTypeResolver(ts, files, dir) {
+  var configPath = ts.findConfigFile(dir, ts.sys.fileExists, "tsconfig.json"),
+    compilerOptions = {
+      target: ts.ScriptTarget.Latest,
+      module: ts.ModuleKind.ESNext,
+      moduleResolution: ts.ModuleResolutionKind.Bundler,
+      strict: !1,
+      skipLibCheck: !0,
+      noEmit: !0
+    };
+  if (configPath) {
+    var configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+    if (configFile.config) {
+      var parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, (0, import_path.dirname)(configPath));
+      compilerOptions = {
+        ...compilerOptions,
+        ...parsed.options
+      };
+    }
+  }
+  var fileMap = /* @__PURE__ */new Map(),
+    _iteratorNormalCompletion = !0,
+    _didIteratorError = !1,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = files[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
+      var f = _step.value;
+      fileMap.set(f.path, f.content);
+    }
+  } catch (err) {
+    _didIteratorError = !0, _iteratorError = err;
+  } finally {
+    try {
+      !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+    } finally {
+      if (_didIteratorError) throw _iteratorError;
+    }
+  }
+  var host = ts.createCompilerHost(compilerOptions),
+    originalGetSourceFile = host.getSourceFile.bind(host);
+  host.getSourceFile = function (fileName, languageVersion, onError) {
+    var content = fileMap.get(fileName);
+    return content !== void 0 ? ts.createSourceFile(fileName, content, languageVersion, !0) : originalGetSourceFile(fileName, languageVersion, onError);
+  }, host.fileExists = function (fileName) {
+    return fileMap.has(fileName) || ts.sys.fileExists(fileName);
+  }, host.readFile = function (fileName) {
+    var _fileMap_get;
+    return (_fileMap_get = fileMap.get(fileName)) !== null && _fileMap_get !== void 0 ? _fileMap_get : ts.sys.readFile(fileName);
+  };
+  var program = ts.createProgram(files.map(function (f2) {
+      return f2.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) {
+  var result = null;
+  return ts.forEachChild(sourceFile, function (node) {
+    var _node_modifiers;
+    if (!result && ts.isVariableStatement(node) && !((_node_modifiers = node.modifiers) === null || _node_modifiers === void 0) && _node_modifiers.some(function (m) {
+      return m.kind === ts.SyntaxKind.ExportKeyword;
+    })) {
+      var decl = node.declarationList.declarations[0];
+      if (!(!decl || !ts.isVariableDeclaration(decl)) && decl.name.getText(sourceFile) === exportName && decl.initializer && ts.isArrowFunction(decl.initializer)) {
+        var param = decl.initializer.parameters[paramIndex];
+        param?.type && (result = resolver.resolveType(param.type));
+      }
+    }
+  }), result;
+}
+function resolveMutationParamTypes(ts, resolver, sourceFile) {
+  var resolved = /* @__PURE__ */new Map();
+  return ts.forEachChild(sourceFile, function (node) {
+    var _node_modifiers;
+    if (ts.isVariableStatement(node) && !((_node_modifiers = node.modifiers) === null || _node_modifiers === void 0) && _node_modifiers.some(function (m) {
+      return m.kind === ts.SyntaxKind.ExportKeyword;
+    })) {
+      var decl = node.declarationList.declarations[0];
+      if (!(!decl || !ts.isVariableDeclaration(decl)) && decl.name.getText(sourceFile) === "mutate" && !(!decl.initializer || !ts.isCallExpression(decl.initializer))) {
+        for (var args = decl.initializer.arguments, handlersArg = null, i = args.length - 1; i >= 0; i--) if (ts.isObjectLiteralExpression(args[i])) {
+          handlersArg = args[i];
+          break;
+        }
+        if (handlersArg) {
+          var _iteratorNormalCompletion = !0,
+            _didIteratorError = !1,
+            _iteratorError = void 0;
+          try {
+            for (var _iterator = handlersArg.properties[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
+              var prop = _step.value,
+                _prop_name;
+              if (!(!ts.isPropertyAssignment(prop) && !ts.isMethodDeclaration(prop))) {
+                var name = (_prop_name = prop.name) === null || _prop_name === void 0 ? void 0 : _prop_name.getText(sourceFile);
+                if (name) {
+                  var params = null;
+                  if (ts.isPropertyAssignment(prop)) {
+                    var init = prop.initializer;
+                    (ts.isArrowFunction(init) || ts.isFunctionExpression(init)) && (params = init.parameters);
+                  } else ts.isMethodDeclaration(prop) && (params = prop.parameters);
+                  if (!(!params || params.length < 2)) {
+                    var typeNode = params[1].type;
+                    if (typeNode) {
+                      var expanded = resolver.resolveType(typeNode);
+                      expanded && resolved.set(name, expanded);
+                    }
+                  }
+                }
+              }
+            }
+          } catch (err) {
+            _didIteratorError = !0, _iteratorError = err;
+          } finally {
+            try {
+              !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+            } finally {
+              if (_didIteratorError) throw _iteratorError;
+            }
+          }
+        }
+      }
+    }
+  }), resolved;
+}
+function extractMutationsFromModel(ts, sourceFile, content, _fileName, silent, typeToValibot, resolvedTypes, resolvedTypeToValibot) {
+  var mutateNode = null;
+  if (ts.forEachChild(sourceFile, function (node) {
+    var _node_modifiers;
+    if (ts.isVariableStatement(node) && !((_node_modifiers = node.modifiers) === null || _node_modifiers === void 0) && _node_modifiers.some(function (m) {
+      return m.kind === ts.SyntaxKind.ExportKeyword;
+    })) {
+      var 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;
+  var call = mutateNode,
+    args = call.arguments,
+    hasCRUD = args.length >= 2,
+    handlersArg = null;
+  args.length === 1 && ts.isObjectLiteralExpression(args[0]) ? handlersArg = args[0] : args.length === 3 && ts.isObjectLiteralExpression(args[2]) && (handlersArg = args[2]);
+  var columns = {},
+    primaryKeys = [];
+  hasCRUD && extractSchemaColumns(ts, sourceFile, columns, primaryKeys);
+  var custom = [];
+  if (handlersArg) {
+    var _iteratorNormalCompletion = !0,
+      _didIteratorError = !1,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = handlersArg.properties[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
+        var prop = _step.value,
+          _prop_name,
+          _secondParam_type;
+        if (!(!ts.isPropertyAssignment(prop) && !ts.isMethodDeclaration(prop))) {
+          var name = (_prop_name = prop.name) === null || _prop_name === void 0 ? void 0 : _prop_name.getText(sourceFile);
+          if (name) {
+            var params = null;
+            if (ts.isPropertyAssignment(prop)) {
+              var init = prop.initializer;
+              (ts.isArrowFunction(init) || ts.isFunctionExpression(init)) && (params = init.parameters);
+            } else ts.isMethodDeclaration(prop) && (params = prop.parameters);
+            if (params) {
+              if (params.length < 2) {
+                custom.push({
+                  name,
+                  paramType: "void",
+                  valibotCode: ""
+                });
+                continue;
+              }
+              var secondParam = params[1],
+                paramType = ((_secondParam_type = secondParam.type) === null || _secondParam_type === void 0 ? void 0 : _secondParam_type.getText(sourceFile)) || "unknown";
+              if (paramType === "unknown") {
+                custom.push({
+                  name,
+                  paramType: "unknown",
+                  valibotCode: ""
+                });
+                continue;
+              }
+              var valibotCode = typeToValibot(paramType);
+              if (!valibotCode && resolvedTypes && resolvedTypeToValibot) {
+                var resolvedType = resolvedTypes.get(name);
+                resolvedType && (valibotCode = resolvedTypeToValibot(resolvedType));
+              }
+              custom.push({
+                name,
+                paramType,
+                valibotCode: valibotCode || ""
+              });
+            }
+          }
+        }
+      }
+    } catch (err) {
+      _didIteratorError = !0, _iteratorError = err;
+    } finally {
+      try {
+        !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+      } finally {
+        if (_didIteratorError) throw _iteratorError;
+      }
+    }
+  }
+  return {
+    modelName: "",
+    hasCRUD,
+    columns,
+    primaryKeys,
+    custom
+  };
+}
+function extractSchemaColumns(ts, sourceFile, columns, primaryKeys) {
+  function visit(node) {
+    if (ts.isCallExpression(node)) {
+      var text = node.expression.getText(sourceFile);
+      if (text.endsWith(".primaryKey")) {
+        var _iteratorNormalCompletion = !0,
+          _didIteratorError = !1,
+          _iteratorError = void 0;
+        try {
+          for (var _iterator = node.arguments[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
+            var arg = _step.value;
+            ts.isStringLiteral(arg) && primaryKeys.push(arg.text);
+          }
+        } catch (err) {
+          _didIteratorError = !0, _iteratorError = err;
+        } finally {
+          try {
+            !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+          } finally {
+            if (_didIteratorError) throw _iteratorError;
+          }
+        }
+      }
+      if (text.endsWith(".columns") && node.arguments.length === 1) {
+        var obj = node.arguments[0];
+        if (ts.isObjectLiteralExpression(obj)) {
+          var _iteratorNormalCompletion1 = !0,
+            _didIteratorError1 = !1,
+            _iteratorError1 = void 0;
+          try {
+            for (var _iterator1 = obj.properties[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = !0) {
+              var prop = _step1.value,
+                _prop_name;
+              if (ts.isPropertyAssignment(prop)) {
+                var colName = (_prop_name = prop.name) === null || _prop_name === void 0 ? void 0 : _prop_name.getText(sourceFile);
+                if (colName) {
+                  var initText = prop.initializer.getText(sourceFile),
+                    colType = parseColumnType(initText);
+                  columns[colName] = colType;
+                }
+              }
+            }
+          } catch (err) {
+            _didIteratorError1 = !0, _iteratorError1 = err;
+          } finally {
+            try {
+              !_iteratorNormalCompletion1 && _iterator1.return != null && _iterator1.return();
+            } finally {
+              if (_didIteratorError1) throw _iteratorError1;
+            }
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+}
+function parseColumnType(initText) {
+  var optional = initText.includes(".optional()"),
+    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) {
+  var 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) {
+  var entries = [];
+  if (mode === "delete") {
+    var _iteratorNormalCompletion = !0,
+      _didIteratorError = !1,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = primaryKeys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
+        var pk = _step.value,
+          col = columns[pk];
+        col && entries.push(`${pk}: ${columnTypeToValibot({
+          ...col,
+          optional: !1
+        })}`);
+      }
+    } catch (err) {
+      _didIteratorError = !0, _iteratorError = err;
+    } finally {
+      try {
+        !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+      } finally {
+        if (_didIteratorError) throw _iteratorError;
+      }
+    }
+  } else if (mode === "update") {
+    var _iteratorNormalCompletion1 = !0,
+      _didIteratorError1 = !1,
+      _iteratorError1 = void 0;
+    try {
+      for (var _iterator1 = Object.entries(columns)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = !0) {
+        var [name, col1] = _step1.value,
+          isPK = primaryKeys.includes(name);
+        isPK ? entries.push(`${name}: ${columnTypeToValibot({
+          ...col1,
+          optional: !1
+        })}`) : entries.push(`${name}: ${columnTypeToValibot({
+          ...col1,
+          optional: !0
+        })}`);
+      }
+    } catch (err) {
+      _didIteratorError1 = !0, _iteratorError1 = err;
+    } finally {
+      try {
+        !_iteratorNormalCompletion1 && _iterator1.return != null && _iterator1.return();
+      } finally {
+        if (_didIteratorError1) throw _iteratorError1;
+      }
+    }
+  } else {
+    var _iteratorNormalCompletion2 = !0,
+      _didIteratorError2 = !1,
+      _iteratorError2 = void 0;
+    try {
+      for (var _iterator2 = Object.entries(columns)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = !0) {
+        var [name1, col2] = _step2.value;
+        entries.push(`${name1}: ${columnTypeToValibot(col2)}`);
+      }
+    } catch (err) {
+      _didIteratorError2 = !0, _iteratorError2 = err;
+    } finally {
+      try {
+        !_iteratorNormalCompletion2 && _iterator2.return != null && _iterator2.return();
+      } finally {
+        if (_didIteratorError2) throw _iteratorError2;
+      }
+    }
+  }
+  return `v.object({
+    ${entries.join(`,
+    `)},
+  })`;
+}
+function generateSyncedMutationsFile(modelMutations) {
+  var sorted = [...modelMutations].sort(function (a, b) {
+      return a.modelName.localeCompare(b.modelName);
+    }),
+    modelDefs = sorted.map(function (model) {
+      var entries = [];
+      if (model.hasCRUD && Object.keys(model.columns).length > 0) for (var _loop = function (_i2, _iter2) {
+          var mode = _iter2[_i2],
+            hasCustomOverride = model.custom.some(function (m) {
+              return m.name === mode;
+            });
+          if (hasCustomOverride) {
+            var customMut = model.custom.find(function (m) {
+              return 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)},`);
+        }, _i = 0, _iter = ["insert", "update", "delete"]; _i < _iter.length; _i++) _loop(_i, _iter);
+      var _iteratorNormalCompletion = !0,
+        _didIteratorError = !1,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = model.custom[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
+          var mut = _step.value;
+          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)},`);
+          }
+        }
+      } catch (err) {
+        _didIteratorError = !0, _iteratorError = err;
+      } finally {
+        try {
+          !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+        } finally {
+          if (_didIteratorError) throw _iteratorError;
+        }
+      }
+      return `  ${model.modelName}: {
+${entries.join(`
+`)}
+  },`;
+    }).join(`
+`);
+  return `// auto-generated by: on-zero generate
+// mutation validators derived from model schemas and handler types
+import * as v from 'valibot'
+
+export const mutationValidators = {
+${modelDefs}
+}
+`;
+}
+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("}")) {
+    var inner = type.slice(1, -1).trim();
+    if (!inner) return "v.object({})";
+    var normalized = inner.replace(/\n/g, "; ").replace(/;\s*;/g, ";"),
+      entries = [],
+      _iteratorNormalCompletion = !0,
+      _didIteratorError = !1,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = normalized.split(";")[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
+        var part = _step.value,
+          trimmed = part.trim().replace(/,\s*$/, "");
+        if (trimmed) {
+          var match = trimmed.match(/^(?:readonly\s+)?(\w+)(\?)?:\s*(.+)$/);
+          if (match) {
+            var [, name, opt, typeStr] = match,
+              parsed = parseTypeString(typeStr.trim());
+            if (!parsed) return null;
+            var val = parsed;
+            opt && (val = `v.optional(${val})`), entries.push(`${name}: ${val}`);
+          }
+        }
+      }
+    } catch (err) {
+      _didIteratorError = !0, _iteratorError = err;
+    } finally {
+      try {
+        !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+      } finally {
+        if (_didIteratorError) throw _iteratorError;
+      }
+    }
+    return entries.length === 0 ? "v.object({})" : `v.object({
+    ${entries.join(`,
+    `)},
+  })`;
+  }
+  if (type.endsWith("[]")) {
+    var inner1 = parseTypeString(type.slice(0, -2).trim());
+    return inner1 ? `v.array(${inner1})` : null;
+  }
+  return null;
+}
+function tsTypeToValibot(ts, checker, type, seen) {
+  seen || (seen = /* @__PURE__ */new Set());
+  var flags = type.getFlags();
+  if (flags & (ts.TypeFlags.Object | ts.TypeFlags.Intersection)) {
+    if (seen.has(type)) return "v.unknown()";
+    seen.add(type);
+  }
+  var recurse = function (t) {
+    return 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) {
+    var name = type.intrinsicName;
+    return `v.literal(${name === "true"})`;
+  }
+  if (type.isUnion()) {
+    var members = type.types,
+      hasNull = members.some(function (t) {
+        return t.getFlags() & ts.TypeFlags.Null;
+      }),
+      hasUndefined = members.some(function (t) {
+        return t.getFlags() & (ts.TypeFlags.Undefined | ts.TypeFlags.Void);
+      }),
+      rest = members.filter(function (t) {
+        return !(t.getFlags() & (ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Void));
+      });
+    if (rest.length === 2 && rest.every(function (t) {
+      return t.getFlags() & ts.TypeFlags.BooleanLiteral;
+    })) {
+      var inner = "v.boolean()";
+      return hasNull && (inner = `v.nullable(${inner})`), hasUndefined && (inner = `v.optional(${inner})`), inner;
+    }
+    if (rest.length === 0) return "v.unknown()";
+    var inner1 = rest.length === 1 ? recurse(rest[0]) : `v.union([${rest.map(function (t) {
+      return recurse(t);
+    }).join(", ")}])`;
+    return hasNull && (inner1 = `v.nullable(${inner1})`), hasUndefined && (inner1 = `v.optional(${inner1})`), inner1;
+  }
+  var resolveSymbolType = function (prop2) {
+    var _prop_declarations;
+    return prop2.valueDeclaration ? checker.getTypeOfSymbolAtLocation(prop2, prop2.valueDeclaration) : !((_prop_declarations = prop2.declarations) === null || _prop_declarations === void 0) && _prop_declarations[0] ? checker.getTypeOfSymbolAtLocation(prop2, prop2.declarations[0]) : checker.getDeclaredTypeOfSymbol(prop2);
+  };
+  if (type.isIntersection()) {
+    var props = type.getProperties();
+    if (props.length === 0) return "v.object({})";
+    var entries = [],
+      _iteratorNormalCompletion = !0,
+      _didIteratorError = !1,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = props[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
+        var prop = _step.value,
+          propType = resolveSymbolType(prop),
+          isOptional = !!(prop.getFlags() & ts.SymbolFlags.Optional),
+          val = recurse(propType);
+        isOptional && !val.startsWith("v.optional(") && (val = `v.optional(${val})`), entries.push(`${prop.getName()}: ${val}`);
+      }
+    } catch (err) {
+      _didIteratorError = !0, _iteratorError = err;
+    } finally {
+      try {
+        !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+      } finally {
+        if (_didIteratorError) throw _iteratorError;
+      }
+    }
+    return `v.object({
+    ${entries.join(`,
+    `)},
+  })`;
+  }
+  var props1 = type.getProperties();
+  if (props1.length > 0 && (type.getFlags() & ts.TypeFlags.Object || type.objectFlags)) {
+    var _type_objectFlags,
+      objectFlags = (_type_objectFlags = type.objectFlags) !== null && _type_objectFlags !== void 0 ? _type_objectFlags : 0;
+    if (objectFlags & ts.ObjectFlags.Reference) {
+      var _typeRef_typeArguments,
+        typeRef = type,
+        symbol = type.getSymbol(),
+        name1 = symbol?.getName();
+      if ((name1 === "Array" || name1 === "ReadonlyArray") && ((_typeRef_typeArguments = typeRef.typeArguments) === null || _typeRef_typeArguments === void 0 ? void 0 : _typeRef_typeArguments.length) === 1) return `v.array(${recurse(typeRef.typeArguments[0])})`;
+    }
+    if (objectFlags & ts.ObjectFlags.Tuple) {
+      var typeRef1 = type,
+        typeArgs = typeRef1.typeArguments || [];
+      return `v.tuple([${typeArgs.map(function (t) {
+        return recurse(t);
+      }).join(", ")}])`;
+    }
+    var entries1 = [],
+      _iteratorNormalCompletion1 = !0,
+      _didIteratorError1 = !1,
+      _iteratorError1 = void 0;
+    try {
+      for (var _iterator1 = props1[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = !0) {
+        var prop1 = _step1.value,
+          propType1 = resolveSymbolType(prop1),
+          isOptional1 = !!(prop1.getFlags() & ts.SymbolFlags.Optional),
+          val1 = recurse(propType1);
+        isOptional1 && !val1.startsWith("v.optional(") && (val1 = `v.optional(${val1})`), entries1.push(`${prop1.getName()}: ${val1}`);
+      }
+    } catch (err) {
+      _didIteratorError1 = !0, _iteratorError1 = err;
+    } finally {
+      try {
+        !_iteratorNormalCompletion1 && _iterator1.return != null && _iterator1.return();
+      } finally {
+        if (_didIteratorError1) throw _iteratorError1;
+      }
+    }
+    return entries1.length === 0 ? "v.object({})" : `v.object({
+    ${entries1.join(`,
+    `)},
+  })`;
+  }
+  var stringIndex = type.getStringIndexType();
+  if (stringIndex) return `v.record(v.string(), ${recurse(stringIndex)})`;
+  var numberIndex = type.getNumberIndexType();
+  return numberIndex ? `v.record(v.number(), ${recurse(numberIndex)})` : "v.unknown()";
+}
 async function generate(options) {
   var {
       dir,
@@ -318,31 +928,48 @@ async function generate(options) {
     }),
     writeResults = [writeFileIfChanged((0, import_path.resolve)(generatedDir, "models.ts"), generateModelsFile(allModelFiles)), writeFileIfChanged((0, import_path.resolve)(generatedDir, "types.ts"), generateTypesFile(filesWithSchema)), writeFileIfChanged((0, import_path.resolve)(generatedDir, "tables.ts"), generateTablesFile(filesWithSchema)), writeFileIfChanged((0, import_path.resolve)(generatedDir, "README.md"), generateReadmeFile())],
     filesChanged = writeResults.filter(Boolean).length,
-    queryCount = 0;
+    queryCount = 0,
+    mutationCount = 0,
+    ts = await import("typescript"),
+    typeToValibot = function (paramType) {
+      try {
+        return parseTypeString(paramType.trim());
+      } catch {
+        return null;
+      }
+    };
   if ((0, import_fs.existsSync)(queriesDir)) {
-    var ts = await import("typescript"),
-      {
-        ModelToValibot
-      } = await import("@sinclair/typebox-codegen/model/index.js"),
-      {
-        TypeScriptToModel
-      } = await import("@sinclair/typebox-codegen/typescript/index.js"),
-      queryFiles = (0, import_fs.readdirSync)(queriesDir).filter(function (f) {
+    var queryFiles = (0, import_fs.readdirSync)(queriesDir).filter(function (f) {
         return f.endsWith(".ts");
       }),
       allQueries = [],
+      queryResolver = null,
+      getQueryResolver = function () {
+        if (!queryResolver) {
+          var allFiles2 = (0, import_fs.readdirSync)(queriesDir).filter(function (f) {
+            return f.endsWith(".ts");
+          }).map(function (f) {
+            return {
+              path: (0, import_path.resolve)(queriesDir, f),
+              content: (0, import_fs.readFileSync)((0, import_path.resolve)(queriesDir, f), "utf-8")
+            };
+          });
+          queryResolver = createTypeResolver(ts, allFiles2, queriesDir);
+        }
+        return queryResolver;
+      },
       _iteratorNormalCompletion = !0,
       _didIteratorError = !1,
       _iteratorError = void 0;
     try {
       for (var _loop = function () {
-          var file = _step.value,
-            filePath = (0, import_path.resolve)(queriesDir, file),
-            fileBaseName = (0, import_path.basename)(file, ".ts");
+          var file2 = _step.value,
+            filePath2 = (0, import_path.resolve)(queriesDir, file2),
+            fileBaseName2 = (0, import_path.basename)(file2, ".ts");
           try {
-            var content = (0, import_fs.readFileSync)(filePath, "utf-8"),
-              sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, !0);
-            ts.forEachChild(sourceFile, function (node) {
+            var content2 = (0, import_fs.readFileSync)(filePath2, "utf-8"),
+              sourceFile2 = ts.createSourceFile(filePath2, content2, ts.ScriptTarget.Latest, !0);
+            ts.forEachChild(sourceFile2, function (node) {
               if (ts.isVariableStatement(node)) {
                 var _node_modifiers,
                   exportModifier = (_node_modifiers = node.modifiers) === null || _node_modifiers === void 0 ? void 0 : _node_modifiers.find(function (m) {
@@ -351,7 +978,7 @@ async function generate(options) {
                 if (!exportModifier) return;
                 var declaration = node.declarationList.declarations[0];
                 if (!declaration || !ts.isVariableDeclaration(declaration)) return;
-                var name = declaration.name.getText(sourceFile);
+                var name = declaration.name.getText(sourceFile2);
                 if (name === "permission") return;
                 if (declaration.initializer && ts.isArrowFunction(declaration.initializer)) {
                   var params = declaration.initializer.parameters,
@@ -359,26 +986,28 @@ async function generate(options) {
                   if (params.length > 0) {
                     var _param_type,
                       param = params[0];
-                    paramType = ((_param_type = param.type) === null || _param_type === void 0 ? void 0 : _param_type.getText(sourceFile)) || "unknown";
+                    paramType = ((_param_type = param.type) === null || _param_type === void 0 ? void 0 : _param_type.getText(sourceFile2)) || "unknown";
                   }
-                  try {
-                    var 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}`);
+                  var valibotCode = typeToValibot(paramType);
+                  if (!valibotCode && params.length > 0 && params[0].type) {
+                    var resolver = getQueryResolver(),
+                      resolverSourceFile = resolver.program.getSourceFile(filePath2);
+                    if (resolverSourceFile) {
+                      var resolvedType = resolveParamType(ts, resolver, resolverSourceFile, name, 0);
+                      resolvedType && (valibotCode = resolver.typeToValibot(resolvedType));
+                    }
                   }
+                  valibotCode ? allQueries.push({
+                    name,
+                    params: paramType,
+                    valibotCode,
+                    sourceFile: fileBaseName2
+                  }) : !silent && paramType !== "void" && console.error(`\u2717 ${name}: could not resolve type "${paramType}"`);
                 }
               }
             });
           } catch (err) {
-            silent || console.error(`Error processing ${file}:`, err);
+            silent || console.error(`Error processing ${file2}:`, err);
           }
         }, _iterator = queryFiles[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) _loop();
     } catch (err) {
@@ -395,7 +1024,138 @@ async function generate(options) {
       syncedChanged = writeFileIfChanged((0, import_path.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) {
+  var allModelMutations = [],
+    mutationFiles = [],
+    unresolvedModels = [],
+    _iteratorNormalCompletion1 = !0,
+    _didIteratorError1 = !1,
+    _iteratorError1 = void 0;
+  try {
+    for (var _iterator1 = allModelFiles[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = !0) {
+      var file = _step1.value,
+        filePath = (0, import_path.resolve)(modelsDir, file),
+        fileBaseName = (0, import_path.basename)(file, ".ts");
+      try {
+        var content = (0, import_fs.readFileSync)(filePath, "utf-8");
+        if (!content.includes("export const mutate")) continue;
+        mutationFiles.push({
+          path: filePath,
+          content,
+          baseName: fileBaseName
+        });
+        var sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, !0),
+          result = extractMutationsFromModel(ts, sourceFile, content, filePath, !!silent, typeToValibot);
+        if (result) {
+          result.modelName = fileBaseName, allModelMutations.push(result);
+          var hasUnresolved = result.custom.some(function (m) {
+            return m.paramType !== "void" && m.paramType !== "unknown" && !m.valibotCode;
+          });
+          hasUnresolved && unresolvedModels.push({
+            baseName: fileBaseName,
+            filePath
+          });
+        }
+      } catch (err) {
+        silent || console.error(`Error extracting mutations from ${file}:`, err);
+      }
+    }
+  } catch (err) {
+    _didIteratorError1 = !0, _iteratorError1 = err;
+  } finally {
+    try {
+      !_iteratorNormalCompletion1 && _iterator1.return != null && _iterator1.return();
+    } finally {
+      if (_didIteratorError1) throw _iteratorError1;
+    }
+  }
+  if (unresolvedModels.length > 0) {
+    var collectTsFiles = function (dir2) {
+        var results = [],
+          _iteratorNormalCompletion4 = !0,
+          _didIteratorError4 = !1,
+          _iteratorError4 = void 0;
+        try {
+          for (var _iterator4 = (0, import_fs.readdirSync)(dir2, {
+              withFileTypes: !0
+            })[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = !0) {
+            var entry = _step4.value,
+              fullPath = (0, import_path.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: (0, import_fs.readFileSync)(fullPath, "utf-8")
+            });
+          }
+        } catch (err) {
+          _didIteratorError4 = !0, _iteratorError4 = err;
+        } finally {
+          try {
+            !_iteratorNormalCompletion4 && _iterator4.return != null && _iterator4.return();
+          } finally {
+            if (_didIteratorError4) throw _iteratorError4;
+          }
+        }
+        return results;
+      },
+      allFiles = collectTsFiles(baseDir),
+      modelResolver = createTypeResolver(ts, allFiles, baseDir),
+      _iteratorNormalCompletion2 = !0,
+      _didIteratorError2 = !1,
+      _iteratorError2 = void 0;
+    try {
+      for (var _loop1 = function () {
+          var {
+              baseName,
+              filePath: filePath2
+            } = _step2.value,
+            resolverSourceFile = modelResolver.program.getSourceFile(filePath2);
+          if (!resolverSourceFile) return "continue";
+          var resolvedTypes = resolveMutationParamTypes(ts, modelResolver, resolverSourceFile);
+          if (resolvedTypes.size === 0) return "continue";
+          var content2 = (0, import_fs.readFileSync)(filePath2, "utf-8"),
+            sourceFile2 = ts.createSourceFile(filePath2, content2, ts.ScriptTarget.Latest, !0),
+            result2 = extractMutationsFromModel(ts, sourceFile2, content2, filePath2, !!silent, typeToValibot, resolvedTypes, modelResolver.typeToValibot);
+          if (result2) {
+            result2.modelName = baseName;
+            var idx = allModelMutations.findIndex(function (m) {
+              return m.modelName === baseName;
+            });
+            idx >= 0 && (allModelMutations[idx] = result2);
+          }
+        }, _iterator2 = unresolvedModels[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = !0) _loop1();
+    } catch (err) {
+      _didIteratorError2 = !0, _iteratorError2 = err;
+    } finally {
+      try {
+        !_iteratorNormalCompletion2 && _iterator2.return != null && _iterator2.return();
+      } finally {
+        if (_didIteratorError2) throw _iteratorError2;
+      }
+    }
+  }
+  var _iteratorNormalCompletion3 = !0,
+    _didIteratorError3 = !1,
+    _iteratorError3 = void 0;
+  try {
+    for (var _loop2 = function () {
+        var model = _step3.value;
+        model.hasCRUD && (mutationCount += 3), mutationCount += model.custom.filter(function (m) {
+          return !model.hasCRUD || !["insert", "update", "delete", "upsert"].includes(m.name);
+        }).length;
+      }, _iterator3 = allModelMutations[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = !0) _loop2();
+  } catch (err) {
+    _didIteratorError3 = !0, _iteratorError3 = err;
+  } finally {
+    try {
+      !_iteratorNormalCompletion3 && _iterator3.return != null && _iterator3.return();
+    } finally {
+      if (_didIteratorError3) throw _iteratorError3;
+    }
+  }
+  if (allModelMutations.length > 0) {
+    var mutationsChanged = writeFileIfChanged((0, import_path.resolve)(generatedDir, "syncedMutations.ts"), generateSyncedMutationsFile(allModelMutations));
+    mutationsChanged && filesChanged++;
+  }
+  if (filesChanged > 0 && !silent && console.info(`\u2713 ${allModelFiles.length} models (${filesWithSchema.length} schemas)${queryCount ? `, ${queryCount} queries` : ""}${mutationCount ? `, ${mutationCount} mutations` : ""}`), filesChanged > 0 && after) {
     var {
       execSync
     } = await import("child_process");
@@ -415,7 +1175,8 @@ async function generate(options) {
     filesChanged,
     modelCount: allModelFiles.length,
     schemaCount: filesWithSchema.length,
-    queryCount
+    queryCount,
+    mutationCount
   };
 }
 async function watch(options) {