on-zero 0.4.1 → 0.4.3

package/dist/cjs/generate-lite.test.native.js

@@ -0,0 +1,234 @@
+"use strict";
+
+var import_vitest = require("vitest"),
+  import_generate_lite = require("./generate-lite.native.js");
+function makeParse(table) {
+  return function (_src, path) {
+    var entry = table[path];
+    if (!entry) throw new Error(`no lite ast fixture for ${path}`);
+    return entry;
+  };
+}
+var DIR = "/proj/src/data";
+(0, import_vitest.describe)("generateLite", function () {
+  (0, import_vitest.test)("emits models.ts, syncedMutations.ts, and README.md from inline types", function () {
+    var files = {
+        [`${DIR}/models/todo.ts`]: "// fake source, parser returns fixture",
+        [`${DIR}/models/user.ts`]: "// fake source, parser returns fixture"
+      },
+      fixtures = {
+        [`${DIR}/models/todo.ts`]: {
+          mutations: [{
+            modelName: "todo",
+            handlers: [{
+              name: "toggle",
+              paramTypeText: "{ id: string; isActive: boolean }"
+            }, {
+              name: "rename",
+              paramTypeText: "{ id: string; title: string }"
+            }],
+            schema: null
+          }],
+          queries: []
+        },
+        [`${DIR}/models/user.ts`]: {
+          mutations: [{
+            modelName: "user",
+            handlers: [{
+              name: "finishOnboarding",
+              // null = no second param / void
+              paramTypeText: null
+            }],
+            schema: null
+          }],
+          queries: []
+        }
+      },
+      result = (0, import_generate_lite.generateLite)({
+        files,
+        dir: DIR,
+        parse: makeParse(fixtures)
+      });
+    (0, import_vitest.expect)(Object.keys(result.files).sort()).toEqual(["README.md", "models.ts", "syncedMutations.ts"]);
+    var models = result.files["models.ts"];
+    (0, import_vitest.expect)(models).toContain("import * as todo from '../models/todo'"), (0, import_vitest.expect)(models).toContain("import * as userPublic from '../models/user'"), (0, import_vitest.expect)(models).toContain("export const models = {");
+    var syncedMutations = result.files["syncedMutations.ts"];
+    (0, import_vitest.expect)(syncedMutations).toContain("toggle:"), (0, import_vitest.expect)(syncedMutations).toContain("v.object({"), (0, import_vitest.expect)(syncedMutations).toContain("id: v.string()"), (0, import_vitest.expect)(syncedMutations).toContain("isActive: v.boolean()"), (0, import_vitest.expect)(syncedMutations).toContain("rename:"), (0, import_vitest.expect)(syncedMutations).toContain("title: v.string()"), (0, import_vitest.expect)(syncedMutations).toContain("finishOnboarding: v.void_()"), (0, import_vitest.expect)(result.modelCount).toBe(2), (0, import_vitest.expect)(result.schemaCount).toBe(0), (0, import_vitest.expect)(result.mutationCount).toBe(3);
+  }), (0, import_vitest.test)("falls back to v.unknown() for type references", function () {
+    var files = {
+        [`${DIR}/models/post.ts`]: "// fake"
+      },
+      fixtures = {
+        [`${DIR}/models/post.ts`]: {
+          mutations: [{
+            modelName: "post",
+            handlers: [{
+              name: "archive",
+              // bare type reference — parseTypeString returns null, so
+              // generate-lite should fall back to v.unknown() rather than
+              // attempting cross-file type resolution.
+              paramTypeText: "ArchiveParams"
+            }, {
+              name: "publish",
+              // primitive, should resolve
+              paramTypeText: "string"
+            }],
+            schema: null
+          }],
+          queries: []
+        }
+      },
+      result = (0, import_generate_lite.generateLite)({
+        files,
+        dir: DIR,
+        parse: makeParse(fixtures)
+      }),
+      synced = result.files["syncedMutations.ts"];
+    (0, import_vitest.expect)(synced).toContain("archive: v.unknown()"), (0, import_vitest.expect)(synced).toContain("publish: v.string()");
+  }), (0, import_vitest.test)("emits query files with v.unknown() fallback for references", function () {
+    var files = {
+        [`${DIR}/models/post.ts`]: "// fake",
+        [`${DIR}/queries/post.ts`]: "// fake"
+      },
+      fixtures = {
+        [`${DIR}/models/post.ts`]: {
+          mutations: [],
+          queries: []
+        },
+        [`${DIR}/queries/post.ts`]: {
+          mutations: [],
+          queries: [
+          // no-arg query → void
+          {
+            name: "allPosts",
+            paramTypeText: null
+          },
+          // inline object → real validator
+          {
+            name: "postById",
+            paramTypeText: "{ id: string }"
+          },
+          // primitive
+          {
+            name: "byAuthorId",
+            paramTypeText: "string"
+          },
+          // type reference → fallback
+          {
+            name: "filtered",
+            paramTypeText: "PostFilter"
+          },
+          // permission should be skipped
+          {
+            name: "permission",
+            paramTypeText: null
+          }]
+        }
+      },
+      result = (0, import_generate_lite.generateLite)({
+        files,
+        dir: DIR,
+        parse: makeParse(fixtures)
+      });
+    (0, import_vitest.expect)(result.files["groupedQueries.ts"]).toBeDefined(), (0, import_vitest.expect)(result.files["syncedQueries.ts"]).toBeDefined();
+    var grouped = result.files["groupedQueries.ts"];
+    (0, import_vitest.expect)(grouped).toContain("export * as post from '../queries/post'");
+    var synced = result.files["syncedQueries.ts"];
+    (0, import_vitest.expect)(synced).toContain("allPosts: defineQuery(() => Queries.post.allPosts())"), (0, import_vitest.expect)(synced).toContain("postById: defineQuery("), (0, import_vitest.expect)(synced).toContain("id: v.string()"), (0, import_vitest.expect)(synced).toContain("byAuthorId: defineQuery("), (0, import_vitest.expect)(synced).toMatch(/byAuthorId: defineQuery\(\s*v\.string\(\)/), (0, import_vitest.expect)(synced).toContain("filtered: defineQuery("), (0, import_vitest.expect)(synced).toMatch(/filtered: defineQuery\(\s*v\.unknown\(\)/), (0, import_vitest.expect)(synced).not.toContain("permission: defineQuery"), (0, import_vitest.expect)(result.queryCount).toBe(4);
+  }), (0, import_vitest.test)("emits types.ts and tables.ts when a model declares a schema inline", function () {
+    var files = {
+        [`${DIR}/models/task.ts`]: "// fake"
+      },
+      fixtures = {
+        [`${DIR}/models/task.ts`]: {
+          mutations: [{
+            modelName: "task",
+            handlers: [],
+            schema: {
+              tableName: "task",
+              primaryKeys: ["id"],
+              columns: [{
+                name: "id",
+                builderText: "string()"
+              }, {
+                name: "title",
+                builderText: "string()"
+              }, {
+                name: "priority",
+                builderText: "number()"
+              }, {
+                name: "done",
+                builderText: "boolean()"
+              }, {
+                name: "note",
+                builderText: "string().optional()"
+              }]
+            }
+          }],
+          queries: []
+        }
+      },
+      result = (0, import_generate_lite.generateLite)({
+        files,
+        dir: DIR,
+        parse: makeParse(fixtures)
+      });
+    (0, import_vitest.expect)(result.schemaCount).toBe(1), (0, import_vitest.expect)(result.files["types.ts"]).toBeDefined(), (0, import_vitest.expect)(result.files["tables.ts"]).toBeDefined();
+    var types = result.files["types.ts"];
+    (0, import_vitest.expect)(types).toContain("export type Task = TableInsertRow<typeof schema.task>");
+    var tables = result.files["tables.ts"];
+    (0, import_vitest.expect)(tables).toContain("export { schema as task } from '../models/task'");
+    var synced = result.files["syncedMutations.ts"];
+    (0, import_vitest.expect)(synced).toContain("insert:"), (0, import_vitest.expect)(synced).toContain("update:"), (0, import_vitest.expect)(synced).toContain("delete:"), (0, import_vitest.expect)(result.mutationCount).toBe(3);
+  }), (0, import_vitest.test)("ignores nested files and non-ts files inside the models directory", function () {
+    var files = {
+        [`${DIR}/models/post.ts`]: "// fake",
+        [`${DIR}/models/README.md`]: "not a model",
+        [`${DIR}/models/helpers/util.ts`]: "nested should be ignored",
+        [`${DIR}/models/post.d.ts`]: "declaration file, ignored"
+      },
+      fixtures = {
+        [`${DIR}/models/post.ts`]: {
+          mutations: [{
+            modelName: "post",
+            handlers: [],
+            schema: null
+          }],
+          queries: []
+        }
+      },
+      result = (0, import_generate_lite.generateLite)({
+        files,
+        dir: DIR,
+        parse: makeParse(fixtures)
+      });
+    (0, import_vitest.expect)(result.modelCount).toBe(1);
+    var models = result.files["models.ts"];
+    (0, import_vitest.expect)(models).toContain("import * as post from '../models/post'"), (0, import_vitest.expect)(models).not.toContain("util"), (0, import_vitest.expect)(models).not.toContain("README");
+  }), (0, import_vitest.test)("infers mutations/ directory when present", function () {
+    var files = {
+        [`${DIR}/mutations/post.ts`]: "// fake"
+      },
+      fixtures = {
+        [`${DIR}/mutations/post.ts`]: {
+          mutations: [{
+            modelName: "post",
+            handlers: [{
+              name: "publish",
+              paramTypeText: "{ id: string }"
+            }],
+            schema: null
+          }],
+          queries: []
+        }
+      },
+      result = (0, import_generate_lite.generateLite)({
+        files,
+        dir: DIR,
+        parse: makeParse(fixtures)
+      }),
+      models = result.files["models.ts"];
+    (0, import_vitest.expect)(models).toContain("from '../mutations/post'");
+  });
+});
+//# sourceMappingURL=generate-lite.test.native.js.map

package/dist/cjs/generate-lite.test.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["import_vitest","require","import_generate_lite","makeParse","table","_src","path","entry","Error","DIR","describe","test","files","fixtures","mutations","modelName","handlers","name","paramTypeText","schema","queries","result","generateLite","dir","parse","expect","Object","keys","sort","toEqual","models","toContain","syncedMutations","modelCount","toBe","schemaCount","mutationCount","synced","toBeDefined","grouped","toMatch","not","queryCount","tableName","primaryKeys","columns","builderText","types","tables"],"sources":["../../src/generate-lite.test.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/cjs/generate.cjs

@@ -38,7 +38,8 @@ __export(generate_exports, {
 module.exports = __toCommonJS(generate_exports);
 var import_node_crypto = require("node:crypto"),
   import_node_fs = require("node:fs"),
-  import_node_path = require("node:path");
+  import_node_path = require("node:path"),
+  import_generate_helpers = require("./generate-helpers.cjs");
 const hash = s => (0, import_node_crypto.createHash)("sha256").update(s).digest("hex");
 let generateCache = {},
   generateCachePath = "";
@@ -75,157 +76,6 @@ function writeFileIfChanged(filePath, content) {
   const contentHash = hash(content);
   return generateCache[filePath] === contentHash && (0, import_node_fs.existsSync)(filePath) ? !1 : ((0, import_node_fs.writeFileSync)(filePath, content, "utf-8"), generateCache[filePath] = contentHash, !0);
 }
-function generateModelsFile(modelFiles, modelsDirName) {
-  const modelNames = modelFiles.map(f => (0, import_node_path.basename)(f, ".ts")).sort(),
-    getImportName = name => name === "user" ? "userPublic" : name,
-    imports = modelNames.map(name => `import * as ${getImportName(name)} from '../${modelsDirName}/${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 => (0, import_node_path.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, modelsDirName) {
-  const modelNames = modelFiles.map(f => (0, import_node_path.basename)(f, ".ts")).sort(),
-    getExportName = name => name === "user" ? "userPublic" : name;
-  return `// auto-generated by: on-zero generate
-
-${modelNames.map(name => `export { schema as ${getExportName(name)} } from '../${modelsDirName}/${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 = {
@@ -392,7 +242,7 @@ function extractSchemaColumns(ts, sourceFile, columns, primaryKeys) {
           const colName = prop.name?.getText(sourceFile);
           if (!colName) continue;
           const initText = prop.initializer.getText(sourceFile),
-            colType = parseColumnType(initText);
+            colType = (0, import_generate_helpers.parseColumnType)(initText);
           columns[colName] = colType;
         }
       }
@@ -401,127 +251,6 @@ function extractSchemaColumns(ts, sourceFile, columns, primaryKeys) {
   }
   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,
-    customType: void 0
-  };
-}
-function columnTypeToValibot(col) {
-  let base = "v.string()";
-  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;
-  }
-  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();
@@ -560,11 +289,11 @@ function tsTypeToValibot(ts, checker, type, seen) {
     const entries = [];
     for (const prop of props2) {
       const name = prop.getName();
-      if (shouldSkipObjectKey(name)) continue;
+      if ((0, import_generate_helpers.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}`);
+      isOptional && !val.startsWith("v.optional(") && (val = `v.optional(${val})`), entries.push(`${(0, import_generate_helpers.formatObjectKey)(name)}: ${val}`);
     }
     return entries.length === 0 ? "v.object({})" : `v.object({
     ${entries.join(`,
@@ -583,11 +312,11 @@ function tsTypeToValibot(ts, checker, type, seen) {
     const entries = [];
     for (const prop of props) {
       const name = prop.getName();
-      if (shouldSkipObjectKey(name)) continue;
+      if ((0, import_generate_helpers.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}`);
+      isOptional && !val.startsWith("v.optional(") && (val = `v.optional(${val})`), entries.push(`${(0, import_generate_helpers.formatObjectKey)(name)}: ${val}`);
     }
     return entries.length === 0 ? "v.object({})" : `v.object({
     ${entries.join(`,
@@ -665,18 +394,20 @@ async function generate(options) {
     recursive: !0
   }), loadCache();
   const allModelFiles = (0, import_node_fs.readdirSync)(modelsDir).filter(f => f.endsWith(".ts")).sort(),
-    filesWithSchema = allModelFiles.filter(f => (0, import_node_fs.readFileSync)((0, import_node_path.resolve)(modelsDir, f), "utf-8").includes("export const schema = table("));
-  let filesChanged = [writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "models.ts"), generateModelsFile(allModelFiles, modelsDirName)),
+    filesWithSchema = allModelFiles.filter(f => (0, import_node_fs.readFileSync)((0, import_node_path.resolve)(modelsDir, f), "utf-8").includes("export const schema = table(")),
+    allModelNames = allModelFiles.map(f => (0, import_node_path.basename)(f, ".ts")),
+    schemaModelNames = filesWithSchema.map(f => (0, import_node_path.basename)(f, ".ts"));
+  let filesChanged = [writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "models.ts"), (0, import_generate_helpers.generateModelsFile)(allModelNames, modelsDirName)),
     // only generate types.ts and tables.ts when model files define schemas.
     // when using drizzle-zero CLI for schema generation, these files are
     // managed externally and should not be overwritten.
-    ...(filesWithSchema.length > 0 ? [writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "types.ts"), generateTypesFile(filesWithSchema)), writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "tables.ts"), generateTablesFile(filesWithSchema, modelsDirName))] : []), writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "README.md"), generateReadmeFile())].filter(Boolean).length,
+    ...(filesWithSchema.length > 0 ? [writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "types.ts"), (0, import_generate_helpers.generateTypesFile)(schemaModelNames)), writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "tables.ts"), (0, import_generate_helpers.generateTablesFile)(schemaModelNames, modelsDirName))] : []), writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "README.md"), (0, import_generate_helpers.generateReadmeFile)())].filter(Boolean).length,
     queryCount = 0,
     mutationCount = 0;
   const ts = await import("typescript"),
     typeToValibot = paramType => {
       try {
-        return parseTypeString(paramType.trim());
+        return (0, import_generate_helpers.parseTypeString)(paramType.trim());
       } catch {
         return null;
       }
@@ -735,8 +466,8 @@ async function generate(options) {
       }
     }
     queryCount = allQueries.length;
-    const groupedChanged = writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "groupedQueries.ts"), generateGroupedQueriesFile(allQueries)),
-      syncedChanged = writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "syncedQueries.ts"), generateSyncedQueriesFile(allQueries));
+    const groupedChanged = writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "groupedQueries.ts"), (0, import_generate_helpers.generateGroupedQueriesFile)(allQueries)),
+      syncedChanged = writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "syncedQueries.ts"), (0, import_generate_helpers.generateSyncedQueriesFile)(allQueries));
     groupedChanged && filesChanged++, syncedChanged && filesChanged++;
   }
   const allModelMutations = [],
@@ -797,7 +528,7 @@ async function generate(options) {
     }
   }
   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((0, import_node_path.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) {
+  if (allModelMutations.length > 0 && writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "syncedMutations.ts"), (0, import_generate_helpers.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");