on-zero 0.4.1 → 0.4.2

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

@@ -0,0 +1,232 @@
+import { describe, expect, test } from "vitest";
+import { generateLite } from "./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";
+describe("generateLite", function () {
+  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 = generateLite({
+        files,
+        dir: DIR,
+        parse: makeParse(fixtures)
+      });
+    expect(Object.keys(result.files).sort()).toEqual(["README.md", "models.ts", "syncedMutations.ts"]);
+    var models = result.files["models.ts"];
+    expect(models).toContain("import * as todo from '../models/todo'"), expect(models).toContain("import * as userPublic from '../models/user'"), expect(models).toContain("export const models = {");
+    var syncedMutations = result.files["syncedMutations.ts"];
+    expect(syncedMutations).toContain("toggle:"), expect(syncedMutations).toContain("v.object({"), expect(syncedMutations).toContain("id: v.string()"), expect(syncedMutations).toContain("isActive: v.boolean()"), expect(syncedMutations).toContain("rename:"), expect(syncedMutations).toContain("title: v.string()"), expect(syncedMutations).toContain("finishOnboarding: v.void_()"), expect(result.modelCount).toBe(2), expect(result.schemaCount).toBe(0), expect(result.mutationCount).toBe(3);
+  }), 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 = generateLite({
+        files,
+        dir: DIR,
+        parse: makeParse(fixtures)
+      }),
+      synced = result.files["syncedMutations.ts"];
+    expect(synced).toContain("archive: v.unknown()"), expect(synced).toContain("publish: v.string()");
+  }), 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 = generateLite({
+        files,
+        dir: DIR,
+        parse: makeParse(fixtures)
+      });
+    expect(result.files["groupedQueries.ts"]).toBeDefined(), expect(result.files["syncedQueries.ts"]).toBeDefined();
+    var grouped = result.files["groupedQueries.ts"];
+    expect(grouped).toContain("export * as post from '../queries/post'");
+    var synced = result.files["syncedQueries.ts"];
+    expect(synced).toContain("allPosts: defineQuery(() => Queries.post.allPosts())"), expect(synced).toContain("postById: defineQuery("), expect(synced).toContain("id: v.string()"), expect(synced).toContain("byAuthorId: defineQuery("), expect(synced).toMatch(/byAuthorId: defineQuery\(\s*v\.string\(\)/), expect(synced).toContain("filtered: defineQuery("), expect(synced).toMatch(/filtered: defineQuery\(\s*v\.unknown\(\)/), expect(synced).not.toContain("permission: defineQuery"), expect(result.queryCount).toBe(4);
+  }), 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 = generateLite({
+        files,
+        dir: DIR,
+        parse: makeParse(fixtures)
+      });
+    expect(result.schemaCount).toBe(1), expect(result.files["types.ts"]).toBeDefined(), expect(result.files["tables.ts"]).toBeDefined();
+    var types = result.files["types.ts"];
+    expect(types).toContain("export type Task = TableInsertRow<typeof schema.task>");
+    var tables = result.files["tables.ts"];
+    expect(tables).toContain("export { schema as task } from '../models/task'");
+    var synced = result.files["syncedMutations.ts"];
+    expect(synced).toContain("insert:"), expect(synced).toContain("update:"), expect(synced).toContain("delete:"), expect(result.mutationCount).toBe(3);
+  }), 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 = generateLite({
+        files,
+        dir: DIR,
+        parse: makeParse(fixtures)
+      });
+    expect(result.modelCount).toBe(1);
+    var models = result.files["models.ts"];
+    expect(models).toContain("import * as post from '../models/post'"), expect(models).not.toContain("util"), expect(models).not.toContain("README");
+  }), 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 = generateLite({
+        files,
+        dir: DIR,
+        parse: makeParse(fixtures)
+      }),
+      models = result.files["models.ts"];
+    expect(models).toContain("from '../mutations/post'");
+  });
+});
+//# sourceMappingURL=generate-lite.test.native.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["describe","expect","test","generateLite","makeParse","table","_src","path","entry","Error","DIR","files","fixtures","mutations","modelName","handlers","name","paramTypeText","schema","queries","result","dir","parse","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":"AAAA,SAASA,QAAA,EAAUC,MAAA,EAAQC,IAAA,QAAY;AAEvC,SAASC,YAAA,QAAoB;AAO7B,SAASC,UAAUC,KAAA,EAAoD;EACrE,OAAO,UAAOC,IAAA,EAAAC,IAAS;IACrB,IAAAC,KAAM,GAAAH,KAAQ,CAAAE,IAAM;IACpB,IAAI,CAACC,KAAA,EACH,MAAM,IAAIC,KAAA,CAAM,2BAA2BF,IAAI,EAAE;IAEnD,OAAOC,KAAA;EACT;AACF;AAEA,IAAAE,GAAM,mBAAM;AAEZV,QAAA,CAAS,gBAAgB,YAAM;EAC7BE,IAAA,CAAK,wEAAwE,YAAM;IACjF,IAAAS,KAAM;QACJ,CAAC,GAAGD,GAAG,iBAAiB,GAAG;QAC3B,CAAC,GAAGA,GAAG,iBAAiB,GAAG;MAC7B;MAEME,QAAA,GAA2C;QAC/C,CAAC,GAAGF,GAAG,iBAAiB,GAAG;UACzBG,SAAA,EAAW,CACT;YACEC,SAAA,EAAW;YACXC,QAAA,EAAU,CACR;cACEC,IAAA,EAAM;cACNC,aAAA,EAAe;YACjB,GACA;cACED,IAAA,EAAM;cACNC,aAAA,EAAe;YACjB,EACF;YACAC,MAAA,EAAQ;UACV,EACF;UACAC,OAAA,EAAS;QACX;QACA,CAAC,GAAGT,GAAG,iBAAiB,GAAG;UACzBG,SAAA,EAAW,CACT;YACEC,SAAA,EAAW;YACXC,QAAA,EAAU,CACR;cACEC,IAAA,EAAM;cAAA;cAENC,aAAA,EAAe;YACjB,EACF;YACAC,MAAA,EAAQ;UACV,EACF;UACAC,OAAA,EAAS;QACX;MACF;MAEMC,MAAA,GAASjB,YAAA,CAAa;QAC1BQ,KAAA;QACAU,GAAA,EAAKX,GAAA;QACLY,KAAA,EAAOlB,SAAA,CAAUQ,QAAQ;MAC3B,CAAC;IAGDX,MAAA,CAAOsB,MAAA,CAAOC,IAAA,CAAKJ,MAAA,CAAOT,KAAK,EAAEc,IAAA,CAAK,CAAC,EAAEC,OAAA,CAAQ,CAC/C,aACA,aACA,qBACD;IAGD,IAAAC,MAAM,GAAAP,MAAS,CAAAT,KAAO,YAAM;IAC5BV,MAAA,CAAO0B,MAAM,EAAEC,SAAA,CAAU,wCAAwC,GACjE3B,MAAA,CAAO0B,MAAM,EAAEC,SAAA,CAAU,8CAA8C,GACvE3B,MAAA,CAAO0B,MAAM,EAAEC,SAAA,CAAU,yBAAyB;IAGlD,IAAAC,eAAM,GAAAT,MAAkB,CAAAT,KAAO,qBAAM;IACrCV,MAAA,CAAO4B,eAAe,EAAED,SAAA,CAAU,SAAS,GAC3C3B,MAAA,CAAO4B,eAAe,EAAED,SAAA,CAAU,YAAY,GAC9C3B,MAAA,CAAO4B,eAAe,EAAED,SAAA,CAAU,gBAAgB,GAClD3B,MAAA,CAAO4B,eAAe,EAAED,SAAA,CAAU,uBAAuB,GACzD3B,MAAA,CAAO4B,eAAe,EAAED,SAAA,CAAU,SAAS,GAC3C3B,MAAA,CAAO4B,eAAe,EAAED,SAAA,CAAU,mBAAmB,GAErD3B,MAAA,CAAO4B,eAAe,EAAED,SAAA,CAAU,6BAA6B,GAE/D3B,MAAA,CAAOmB,MAAA,CAAOU,UAAU,EAAEC,IAAA,CAAK,CAAC,GAChC9B,MAAA,CAAOmB,MAAA,CAAOY,WAAW,EAAED,IAAA,CAAK,CAAC,GACjC9B,MAAA,CAAOmB,MAAA,CAAOa,aAAa,EAAEF,IAAA,CAAK,CAAC;EACrC,CAAC,GAED7B,IAAA,CAAK,iDAAiD,YAAM;IAC1D,IAAAS,KAAM;QACJ,CAAC,GAAGD,GAAG,iBAAiB,GAAG;MAC7B;MAEME,QAAA,GAA2C;QAC/C,CAAC,GAAGF,GAAG,iBAAiB,GAAG;UACzBG,SAAA,EAAW,CACT;YACEC,SAAA,EAAW;YACXC,QAAA,EAAU,CACR;cACEC,IAAA,EAAM;cAAA;cAAA;cAAA;cAINC,aAAA,EAAe;YACjB,GACA;cACED,IAAA,EAAM;cAAA;cAENC,aAAA,EAAe;YACjB,EACF;YACAC,MAAA,EAAQ;UACV,EACF;UACAC,OAAA,EAAS;QACX;MACF;MAQMC,MAAA,GANSjB,YAAA,CAAa;QAC1BQ,KAAA;QACAU,GAAA,EAAKX,GAAA;QACLY,KAAA,EAAOlB,SAAA,CAAUQ,QAAQ;MAC3B,CAAC;MAEqBsB,MAAM,GAAAd,MAAA,CAAAT,KAAA,qBAAoB;IAChDV,MAAA,CAAOiC,MAAM,EAAEN,SAAA,CAAU,sBAAsB,GAC/C3B,MAAA,CAAOiC,MAAM,EAAEN,SAAA,CAAU,qBAAqB;EAChD,CAAC,GAED1B,IAAA,CAAK,8DAA8D,YAAM;IACvE,IAAAS,KAAM;QACJ,CAAC,GAAGD,GAAG,iBAAiB,GAAG;QAC3B,CAAC,GAAGA,GAAG,kBAAkB,GAAG;MAC9B;MAEME,QAAA,GAA2C;QAC/C,CAAC,GAAGF,GAAG,iBAAiB,GAAG;UACzBG,SAAA,EAAW,EAAC;UACZM,OAAA,EAAS;QACX;QACA,CAAC,GAAGT,GAAG,kBAAkB,GAAG;UAC1BG,SAAA,EAAW,EAAC;UACZM,OAAA,EAAS;UAAA;UAEP;YAAwCH,IAAA;YAEtCC,aAAM;UAA4C;UAEpD;UAA8C;YAE5CD,IAAA,EAAM;YAAwCC,aAAA;UAEhD;UACF;UACF;YAGID,IAAS,cAAa;YAC1BC,aAAA;UACA,CAAK;UACL;UACD;YAGMD,IAAA,EAAO,UAAM;YAGdC,aAAU,EAAO;UACvB,CAAO;UAED;UACN;YAeGD,IAAA;YACGC,aAAgC;UAChC;QAIJ;MAA2B;MAAAG,MACzB,GAAAjB,YAAW;QAAAQ,KACT;QAAAU,GAAA,EAAAX,GACE;QAAWY,KAAA,EACXlB,SAAU,CAACQ,QAAA;MAAA;IACHX,MAAA,CAAAmB,MACN,CAAAT,KAAA,oBAAW,GAAAwB,WAAA,IAAAlC,MAAA,CAAAmB,MAAA,CAAAT,KAAA,sBAAAwB,WAAA;IAAA,IAAAC,OACX,GAAAhB,MAAA,CAAAT,KAAc,oBAAI;IAAAV,MAAA,CAAAmC,OAClB,EAAAR,SAAS;IAAA,IAAAM,MAAA,GACPd,MAAE,CAAMT,KAAA,CAAM,kBAAa;IAAWV,MAAA,CAAAiC,MACtC,CAAE,CAAAN,SAAM,uDAAiC,GAAA3B,MAAA,CAAAiC,MAAA,EAAAN,SAAA,4BAAA3B,MAAA,CAAAiC,MAAA,EAAAN,SAAA,oBAAA3B,MAAA,CAAAiC,MAAA,EAAAN,SAAA,8BAAA3B,MAAA,CAAAiC,MAAA,EAAAG,OAAA,+CAAApC,MAAA,CAAAiC,MAAA,EAAAN,SAAA,4BAAA3B,MAAA,CAAAiC,MAAA,EAAAG,OAAA,8CAAApC,MAAA,CAAAiC,MAAA,EAAAI,GAAA,CAAAV,SAAA,6BAAA3B,MAAA,CAAAmB,MAAA,CAAAmB,UAAA,EAAAR,IAAA;EAAA,IAAA7B,IAAA,qEACG;IAAA,IAAAS,KAAA,GAC5C;QAAyC,IAAAD,GAAA,iBACjC,GAAQ;MAAmC;MAAAE,QACrD;QAAA,IAAAF,GACF;UAAAG,SACF,GACF;YACAC,SAAU;YACZC,QAAA;YAGIG,MAAS;cACbsB,SAAA;cACKC,WAAA,GACE,KACR;cAEMC,OAAO,GAIR;gBACQ1B,IAAA,MAAU;gBAElB2B,WAAgB;cACf,CAAM,EAGP;gBACO3B,IAAE,SAAU;gBAOtB2B,WAAA;cACG,GACG;gBACA3B,IAAA,YAAmB;gBACnB2B,WAAA;cACA,GAGH;gBACG3B,IAAA,QAAiB;gBACtB2B,WAAc;cACd,CAAS,EACX;gBAGa3B,IAAA,QAAa;gBAC1B2B,WAAA;cACK;YAEN;UAED,CAAO,CACP;UACAxB,OAAO,EAAM;QAKf;MACE;MAAAC,MAAM,GAAAjB,YAAgC;QACpCQ,KAAI;QACNU,GAEM,EAAAX,GAAA;QACJY,KAAI,EAAGlB,SAAA,CAAAQ,QAAA;MAAuB;IACjBX,MACT,CAAAmB,MAAA,CAAAY,WAAA,EAAAD,IAAA,KAAA9B,MAAA,CAAAmB,MAAA,CAAAT,KAAA,cAAAwB,WAAA,IAAAlC,MAAA,CAAAmB,MAAA,CAAAT,KAAA,eAAAwB,WAAA;IAAA,IAAAS,KACE,GAAAxB,MAAA,CAAWT,KAAA;IAAAV,MAAA,CAAA2C,KACX,EAAAhB,SAAa,wDAAkD;IAAA,IAAAiB,MAC/D,GAAAzB,MAAQ,CAAAT,KAAA;IAAAV,MACV,CAAA4C,MAAA,EAAAjB,SAAA;IAAA,IACFM,MAAA,GAAAd,MAAA,CAAAT,KAAA;IAAAV,MACA,CAAAiC,MAAS,CAAC,CAAAN,SAAA,aAAA3B,MAAA,CAAAiC,MAAA,EAAAN,SAAA,aAAA3B,MAAA,CAAAiC,MAAA,EAAAN,SAAA,aAAA3B,MAAA,CAAAmB,MAAA,CAAAa,aAAA,EAAAF,IAAA;EAAA,IACZ7B,IAAA;IACF,IASMS,KAAA,GAPS;QACb,IAAAD,GAAA;QACA,IAAAA,GAAK;QACL,IAAAA,GAAO,yBAAkB;QAC1B,CAGqB,GAAAA,GAAM,mBAAW;MACvC;MAAAE,QAAO,GAAM;QACd,IAAAF,GAAA;UACFG,SAAA,G","ignoreList":[]}

package/dist/esm/generate.mjs

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { basename, dirname, resolve } from "node:path";
+import { formatObjectKey, generateGroupedQueriesFile, generateModelsFile, generateReadmeFile, generateSyncedMutationsFile, generateSyncedQueriesFile, generateTablesFile, generateTypesFile, parseColumnType, parseTypeString, shouldSkipObjectKey } from "./generate-helpers.mjs";
 const hash = s => createHash("sha256").update(s).digest("hex");
 let generateCache = {},
   generateCachePath = "";
@@ -37,157 +38,6 @@ 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, modelsDirName) {
-  const modelNames = modelFiles.map(f => 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 => 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 => 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 = {
@@ -363,127 +213,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();
@@ -627,12 +356,14 @@ async function generate(options) {
     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, modelsDirName)),
+    filesWithSchema = allModelFiles.filter(f => readFileSync(resolve(modelsDir, f), "utf-8").includes("export const schema = table(")),
+    allModelNames = allModelFiles.map(f => basename(f, ".ts")),
+    schemaModelNames = filesWithSchema.map(f => basename(f, ".ts"));
+  let filesChanged = [writeFileIfChanged(resolve(generatedDir, "models.ts"), generateModelsFile(allModelNames, modelsDirName)),
     // only generate types.ts and tables.ts when model files define schemas.
     // when using drizzle-zero CLI for schema generation, these files are
     // managed externally and should not be overwritten.
-    ...(filesWithSchema.length > 0 ? [writeFileIfChanged(resolve(generatedDir, "types.ts"), generateTypesFile(filesWithSchema)), writeFileIfChanged(resolve(generatedDir, "tables.ts"), generateTablesFile(filesWithSchema, modelsDirName))] : []), writeFileIfChanged(resolve(generatedDir, "README.md"), generateReadmeFile())].filter(Boolean).length,
+    ...(filesWithSchema.length > 0 ? [writeFileIfChanged(resolve(generatedDir, "types.ts"), generateTypesFile(schemaModelNames)), writeFileIfChanged(resolve(generatedDir, "tables.ts"), generateTablesFile(schemaModelNames, modelsDirName))] : []), writeFileIfChanged(resolve(generatedDir, "README.md"), generateReadmeFile())].filter(Boolean).length,
     queryCount = 0,
     mutationCount = 0;
   const ts = await import("typescript"),