on-zero 0.2.9 → 0.3.0

package/dist/esm/generate.js

@@ -1,789 +0,0 @@
-import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
-import { basename, dirname, resolve } from "node:path";
-const hash = (s) => createHash("sha256").update(s).digest("hex");
-let generateCache = {}, generateCachePath = "";
-function getCacheDir() {
-  let dir = process.cwd();
-  for (; dir !== "/"; ) {
-    const nm = resolve(dir, "node_modules");
-    if (existsSync(nm)) {
-      const cacheDir = resolve(nm, ".on-zero");
-      return existsSync(cacheDir) || mkdirSync(cacheDir, { recursive: !0 }), cacheDir;
-    }
-    dir = resolve(dir, "..");
-  }
-  return null;
-}
-function loadCache() {
-  const cacheDir = getCacheDir();
-  if (cacheDir) {
-    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");
-}
-function writeFileIfChanged(filePath, content) {
-  const contentHash = hash(content);
-  return generateCache[filePath] === contentHash && existsSync(filePath) ? !1 : (writeFileSync(filePath, content, "utf-8"), generateCache[filePath] = contentHash, !0);
-}
-function generateModelsFile(modelFiles) {
-  const modelNames = modelFiles.map((f) => basename(f, ".ts")).sort(), getImportName = (name) => name === "user" ? "userPublic" : name, imports = modelNames.map((name) => `import * as ${getImportName(name)} from '../models/${name}'`).join(`
-`), modelsObj = `export const models = {
-${[...modelNames].sort(
-    (a, b) => getImportName(a).localeCompare(getImportName(b))
-  ).map((name) => `  ${getImportName(name)},`).join(`
-`)}
-}`;
-  return `// auto-generated by: on-zero generate
-${imports}
-
-${modelsObj}
-`;
-}
-function generateTypesFile(modelFiles) {
-  const modelNames = modelFiles.map((f) => basename(f, ".ts")).sort(), getSchemaName = (name) => name === "user" ? "userPublic" : name;
-  return `import type { TableInsertRow, TableUpdateRow } from 'on-zero'
-import type * as schema from './tables'
-
-${modelNames.map((name) => {
-    const pascalName = name.charAt(0).toUpperCase() + name.slice(1), schemaName = getSchemaName(name);
-    return `export type ${pascalName} = TableInsertRow<typeof schema.${schemaName}>
-export type ${pascalName}Update = TableUpdateRow<typeof schema.${schemaName}>`;
-  }).join(`
-
-`)}
-`;
-}
-function generateTablesFile(modelFiles) {
-  const modelNames = modelFiles.map((f) => basename(f, ".ts")).sort(), getExportName = (name) => name === "user" ? "userPublic" : name;
-  return `// auto-generated by: on-zero generate
-// this is separate from models as otherwise you end up with circular types :/
-
-${modelNames.map((name) => `export { schema as ${getExportName(name)} } from '../models/${name}'`).join(`
-`)}
-`;
-}
-function generateReadmeFile() {
-  return `# generated
-
-this folder is auto-generated by on-zero. do not edit files here directly.
-
-## what's generated
-
-- \`models.ts\` - exports all models from ../models
-- \`types.ts\` - typescript types derived from table schemas
-- \`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
-
-**do not import generated files outside of the data folder.**
-
-### queries
-
-write your queries as plain functions in \`../queries/\` and import them directly:
-
-\`\`\`ts
-// \u2705 good - import from queries
-import { channelMessages } from '~/data/queries/message'
-\`\`\`
-
-the generated query files are only used internally by zero client/server setup.
-
-### types
-
-you can import types from this folder, but prefer re-exporting from \`../types.ts\`:
-
-\`\`\`ts
-// \u274C okay but not preferred
-import type { Message } from '~/data/generated/types'
-
-// \u2705 better - re-export from types.ts
-import type { Message } from '~/data/types'
-\`\`\`
-
-## regeneration
-
-files are regenerated when you run:
-
-\`\`\`bash
-bun on-zero generate
-\`\`\`
-
-or in watch mode:
-
-\`\`\`bash
-bun on-zero generate --watch
-\`\`\`
-
-## more info
-
-see the [on-zero readme](./node_modules/on-zero/README.md) for full documentation.
-`;
-}
-function generateGroupedQueriesFile(queries) {
-  return `/**
- * auto-generated by: on-zero generate
- *
- * grouped query re-exports for minification-safe query identity.
- * this file re-exports all query modules - while this breaks tree-shaking,
- * queries are typically small and few in number even in larger apps.
- */
-${[...new Set(queries.map((q) => q.sourceFile))].sort().map((file) => `export * as ${file} from '../queries/${file}'`).join(`
-`)}
-`;
-}
-function generateSyncedQueriesFile(queries) {
-  const queryByFile = /* @__PURE__ */ new Map();
-  for (const q of queries)
-    queryByFile.has(q.sourceFile) || queryByFile.set(q.sourceFile, []), queryByFile.get(q.sourceFile).push(q);
-  const sortedFiles = Array.from(queryByFile.keys()).sort(), imports = `// auto-generated by: on-zero generate
-// server-side query definitions with validators
-import { defineQuery, defineQueries } from '@rocicorp/zero'
-import * as v from 'valibot'
-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 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(`
-`);
-      return `  ${q.name}: defineQuery(
-    ${indentedValidator},
-    ({ args }) => Queries.${file}.${q.name}(args)
-  ),`;
-    }).join(`
-`);
-    return `const ${file} = {
-${queryDefs}
-}`;
-  }).join(`
-
-`), queriesObject = sortedFiles.map((file) => `  ${file},`).join(`
-`);
-  return `${imports}
-${namespaceDefs}
-
-export const queries = defineQueries({
-${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 {
-      modelName: basename(fileName, ".ts"),
-      hasCRUD: !1,
-      columns: {},
-      primaryKeys: [],
-      custom: []
-    };
-  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 shouldSkipObjectKey(name) {
-  return name.startsWith("__@");
-}
-function formatObjectKey(name) {
-  return /^[$A-Z_a-z][$\w]*$/.test(name) ? name : JSON.stringify(name);
-}
-function schemaColumnsToValibot(columns, primaryKeys, mode) {
-  const entries = [];
-  if (mode === "delete")
-    for (const pk of primaryKeys) {
-      const col = columns[pk];
-      col && entries.push(
-        `${formatObjectKey(pk)}: ${columnTypeToValibot({ ...col, optional: !1 })}`
-      );
-    }
-  else if (mode === "update")
-    for (const [name, col] of Object.entries(columns))
-      primaryKeys.includes(name) ? entries.push(
-        `${formatObjectKey(name)}: ${columnTypeToValibot({ ...col, optional: !1 })}`
-      ) : entries.push(
-        `${formatObjectKey(name)}: ${columnTypeToValibot({ ...col, optional: !0 })}`
-      );
-  else
-    for (const [name, col] of Object.entries(columns))
-      entries.push(`${formatObjectKey(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(`${formatObjectKey(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 name = prop.getName();
-      if (shouldSkipObjectKey(name)) continue;
-      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(`${formatObjectKey(name)}: ${val}`);
-    }
-    return entries.length === 0 ? "v.object({})" : `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 name = prop.getName();
-      if (shouldSkipObjectKey(name)) continue;
-      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(`${formatObjectKey(name)}: ${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, after, silent } = options, baseDir = resolve(dir), modelsDir = resolve(baseDir, "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(")
-  );
-  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, mutationCount = 0;
-  const ts = await import("typescript"), typeToValibot = (paramType) => {
-    try {
-      return parseTypeString(paramType.trim());
-    } catch {
-      return null;
-    }
-  };
-  if (existsSync(queriesDir)) {
-    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");
-      try {
-        const content = readFileSync(filePath, "utf-8"), sourceFile = ts.createSourceFile(
-          filePath,
-          content,
-          ts.ScriptTarget.Latest,
-          !0
-        );
-        ts.forEachChild(sourceFile, (node) => {
-          if (ts.isVariableStatement(node)) {
-            if (!node.modifiers?.find(
-              (m) => m.kind === ts.SyntaxKind.ExportKeyword
-            )) return;
-            const declaration = node.declarationList.declarations[0];
-            if (!declaration || !ts.isVariableDeclaration(declaration)) return;
-            const name = declaration.name.getText(sourceFile);
-            if (name === "permission") return;
-            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");
-              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}"`);
-            }
-          }
-        });
-      } catch (err) {
-        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 allModelMutations = [], mutationFiles = [], unresolvedModels = [];
-  for (const file of allModelFiles) {
-    const filePath = resolve(modelsDir, file), fileBaseName = basename(file, ".ts");
-    try {
-      const content = readFileSync(filePath, "utf-8");
-      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");
-    try {
-      execSync(after, {
-        stdio: "inherit",
-        env: { ...process.env, ON_ZERO_GENERATED_DIR: generatedDir }
-      });
-    } catch (err) {
-      silent || console.error(`Error running after command: ${err}`);
-    }
-  }
-  return saveCache(), {
-    filesChanged,
-    modelCount: allModelFiles.length,
-    schemaCount: filesWithSchema.length,
-    queryCount,
-    mutationCount
-  };
-}
-async function watch(options) {
-  const { dir, debounce = 1e3 } = options, baseDir = resolve(dir), modelsDir = resolve(baseDir, "models"), queriesDir = resolve(baseDir, "queries"), generatedDir = resolve(baseDir, "generated");
-  await generate({ ...options, silent: !0 }), console.info(`\u{1F440} watching...
-`);
-  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;
-}
-export {
-  generate,
-  watch
-};
-//# sourceMappingURL=generate.js.map