on-zero 0.4.1 → 0.4.2

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

@@ -0,0 +1,269 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var generate_lite_exports = {};
+__export(generate_lite_exports, {
+  generateLite: () => generateLite
+});
+module.exports = __toCommonJS(generate_lite_exports);
+var import_generate_helpers = require("./generate-helpers.native.js");
+function stripTrailingSlash(s) {
+  return s.endsWith("/") ? s.slice(0, -1) : s;
+}
+function baseName(path, ext) {
+  var idx = path.lastIndexOf("/"),
+    base = idx >= 0 ? path.slice(idx + 1) : path;
+  return ext && base.endsWith(ext) && (base = base.slice(0, -ext.length)), base;
+}
+function listDirectTsFiles(files, dirPrefix) {
+  var prefix = stripTrailingSlash(dirPrefix) + "/",
+    out = [],
+    _iteratorNormalCompletion = !0,
+    _didIteratorError = !1,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = Object.keys(files)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
+      var path = _step.value;
+      if (path.startsWith(prefix)) {
+        var rest = path.slice(prefix.length);
+        rest.includes("/") || rest.endsWith(".ts") && (rest.endsWith(".d.ts") || out.push(path));
+      }
+    }
+  } catch (err) {
+    _didIteratorError = !0, _iteratorError = err;
+  } finally {
+    try {
+      !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+    } finally {
+      if (_didIteratorError) throw _iteratorError;
+    }
+  }
+  return out.sort();
+}
+function generateLite(opts) {
+  var {
+      files,
+      parse
+    } = opts,
+    baseDir = stripTrailingSlash(opts.dir),
+    modelsDirName;
+  if (opts.modelsDir) modelsDirName = opts.modelsDir;else {
+    var mutationsPrefix = `${baseDir}/mutations/`,
+      hasMutationsDir = Object.keys(files).some(function (p) {
+        return p.startsWith(mutationsPrefix);
+      });
+    modelsDirName = hasMutationsDir ? "mutations" : "models";
+  }
+  var modelsDirPath = `${baseDir}/${modelsDirName}`,
+    queriesDirPath = `${baseDir}/queries`,
+    modelFilePaths = listDirectTsFiles(files, modelsDirPath),
+    queryFilePaths = listDirectTsFiles(files, queriesDirPath),
+    allModelMutations = [],
+    modelNamesWithSchema = [],
+    _iteratorNormalCompletion = !0,
+    _didIteratorError = !1,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = modelFilePaths[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
+      var filePath = _step.value,
+        modelName = baseName(filePath, ".ts"),
+        content = files[filePath],
+        parsed = parse(content, filePath),
+        _parsed_mutations_,
+        mutationExport = (_parsed_mutations_ = parsed.mutations[0]) !== null && _parsed_mutations_ !== void 0 ? _parsed_mutations_ : null,
+        columns = {},
+        primaryKeys = [],
+        hasSchema = !1;
+      if (mutationExport?.schema) {
+        hasSchema = !0, modelNamesWithSchema.push(modelName);
+        var _iteratorNormalCompletion1 = !0,
+          _didIteratorError1 = !1,
+          _iteratorError1 = void 0;
+        try {
+          for (var _iterator1 = mutationExport.schema.primaryKeys[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = !0) {
+            var pk = _step1.value;
+            primaryKeys.push(pk);
+          }
+        } catch (err) {
+          _didIteratorError1 = !0, _iteratorError1 = err;
+        } finally {
+          try {
+            !_iteratorNormalCompletion1 && _iterator1.return != null && _iterator1.return();
+          } finally {
+            if (_didIteratorError1) throw _iteratorError1;
+          }
+        }
+        var _iteratorNormalCompletion2 = !0,
+          _didIteratorError2 = !1,
+          _iteratorError2 = void 0;
+        try {
+          for (var _iterator2 = mutationExport.schema.columns[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = !0) {
+            var col = _step2.value;
+            columns[col.name] = (0, import_generate_helpers.parseColumnType)(col.builderText);
+          }
+        } catch (err) {
+          _didIteratorError2 = !0, _iteratorError2 = err;
+        } finally {
+          try {
+            !_iteratorNormalCompletion2 && _iterator2.return != null && _iterator2.return();
+          } finally {
+            if (_didIteratorError2) throw _iteratorError2;
+          }
+        }
+      }
+      var hasCRUD = hasSchema && mutationExport !== null,
+        _mutationExport_handlers,
+        custom = ((_mutationExport_handlers = mutationExport?.handlers) !== null && _mutationExport_handlers !== void 0 ? _mutationExport_handlers : []).map(function (h) {
+          if (h.paramTypeText == null) return {
+            name: h.name,
+            paramType: "void",
+            valibotCode: ""
+          };
+          var paramType2 = h.paramTypeText.trim();
+          if (paramType2 === "unknown") return {
+            name: h.name,
+            paramType: "unknown",
+            valibotCode: ""
+          };
+          var valibotCode2 = null;
+          try {
+            valibotCode2 = (0, import_generate_helpers.parseTypeString)(paramType2);
+          } catch {
+            valibotCode2 = null;
+          }
+          return {
+            name: h.name,
+            paramType: paramType2,
+            valibotCode: valibotCode2 ?? "v.unknown()"
+          };
+        });
+      allModelMutations.push({
+        modelName,
+        hasCRUD,
+        columns,
+        primaryKeys,
+        custom
+      });
+    }
+  } catch (err) {
+    _didIteratorError = !0, _iteratorError = err;
+  } finally {
+    try {
+      !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+    } finally {
+      if (_didIteratorError) throw _iteratorError;
+    }
+  }
+  var allQueries = [],
+    _iteratorNormalCompletion3 = !0,
+    _didIteratorError3 = !1,
+    _iteratorError3 = void 0;
+  try {
+    for (var _iterator3 = queryFilePaths[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = !0) {
+      var filePath1 = _step3.value,
+        fileBaseName = baseName(filePath1, ".ts"),
+        content1 = files[filePath1],
+        parsed1 = parse(content1, filePath1),
+        _iteratorNormalCompletion4 = !0,
+        _didIteratorError4 = !1,
+        _iteratorError4 = void 0;
+      try {
+        for (var _iterator4 = parsed1.queries[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = !0) {
+          var q = _step4.value;
+          if (q.name !== "permission") {
+            if (q.paramTypeText == null) {
+              allQueries.push({
+                name: q.name,
+                params: "void",
+                valibotCode: "",
+                sourceFile: fileBaseName
+              });
+              continue;
+            }
+            var paramType = q.paramTypeText.trim(),
+              valibotCode = null;
+            try {
+              valibotCode = (0, import_generate_helpers.parseTypeString)(paramType);
+            } catch {
+              valibotCode = null;
+            }
+            allQueries.push({
+              name: q.name,
+              params: paramType,
+              valibotCode: valibotCode ?? "v.unknown()",
+              sourceFile: fileBaseName
+            });
+          }
+        }
+      } catch (err) {
+        _didIteratorError4 = !0, _iteratorError4 = err;
+      } finally {
+        try {
+          !_iteratorNormalCompletion4 && _iterator4.return != null && _iterator4.return();
+        } finally {
+          if (_didIteratorError4) throw _iteratorError4;
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError3 = !0, _iteratorError3 = err;
+  } finally {
+    try {
+      !_iteratorNormalCompletion3 && _iterator3.return != null && _iterator3.return();
+    } finally {
+      if (_didIteratorError3) throw _iteratorError3;
+    }
+  }
+  var modelNames = modelFilePaths.map(function (p) {
+      return baseName(p, ".ts");
+    }),
+    out = {};
+  out["models.ts"] = (0, import_generate_helpers.generateModelsFile)(modelNames, modelsDirName), modelNamesWithSchema.length > 0 && (out["types.ts"] = (0, import_generate_helpers.generateTypesFile)(modelNamesWithSchema), out["tables.ts"] = (0, import_generate_helpers.generateTablesFile)(modelNamesWithSchema, modelsDirName)), out["README.md"] = (0, import_generate_helpers.generateReadmeFile)(), queryFilePaths.length > 0 && (out["groupedQueries.ts"] = (0, import_generate_helpers.generateGroupedQueriesFile)(allQueries), out["syncedQueries.ts"] = (0, import_generate_helpers.generateSyncedQueriesFile)(allQueries)), allModelMutations.length > 0 && (out["syncedMutations.ts"] = (0, import_generate_helpers.generateSyncedMutationsFile)(allModelMutations));
+  var mutationCount = 0,
+    _iteratorNormalCompletion5 = !0,
+    _didIteratorError5 = !1,
+    _iteratorError5 = void 0;
+  try {
+    for (var _loop = function () {
+        var m = _step5.value;
+        m.hasCRUD && (mutationCount += 3), mutationCount += m.custom.filter(function (mut) {
+          return !m.hasCRUD || !["insert", "update", "delete", "upsert"].includes(mut.name);
+        }).length;
+      }, _iterator5 = allModelMutations[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = !0) _loop();
+  } catch (err) {
+    _didIteratorError5 = !0, _iteratorError5 = err;
+  } finally {
+    try {
+      !_iteratorNormalCompletion5 && _iterator5.return != null && _iterator5.return();
+    } finally {
+      if (_didIteratorError5) throw _iteratorError5;
+    }
+  }
+  return {
+    files: out,
+    modelCount: modelNames.length,
+    queryCount: allQueries.length,
+    mutationCount,
+    schemaCount: modelNamesWithSchema.length
+  };
+}
+//# sourceMappingURL=generate-lite.native.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","generate_lite_exports","__export","generateLite","module","exports","import_generate_helpers","require","stripTrailingSlash","s","endsWith","slice","baseName","path","ext","idx","lastIndexOf","base","length","listDirectTsFiles","files","dirPrefix","prefix","out","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_iterator","Object","keys","Symbol","iterator","_step","next","done","startsWith","rest","includes","push","err","return","sort","opts","parse","baseDir","dir","modelsDirName","modelsDir","mutationsPrefix","hasMutationsDir","some","p","modelsDirPath","queriesDirPath","modelFilePaths","queryFilePaths","allModelMutations","modelNamesWithSchema","filePath","modelName","content","parsed","_parsed_mutations_","mutationExport","mutations","columns","primaryKeys","hasSchema","schema","_iteratorNormalCompletion1","_didIteratorError1","_iteratorError1","_iterator1","_step1","pk","_iteratorNormalCompletion2","_didIteratorError2","_iteratorError2","_iterator2","_step2","col","name","parseColumnType","builderText","hasCRUD","_mutationExport_handlers","custom","handlers","map","h","paramTypeText","paramType","valibotCode","paramType2","trim","valibotCode2","parseTypeString"],"sources":["../../src/generate-lite.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,qBAAA;AAAAC,QAAA,CAAAD,qBAAA;EAAAE,YAAA,EAAAA,CAAA,KAAAA;AAAA;AAgBAC,MAAA,CAAAC,OAAA,GAAAT,YAAA,CAUOK,qBAAA;AAuFP,IAAAK,uBAAS,GAAmBC,OAAmB;AAC7C,SAAOC,kBAAkBA,CAAAC,CAAE;EAC7B,OAAAA,CAAA,CAAAC,QAAA,QAAAD,CAAA,CAAAE,KAAA,UAAAF,CAAA;AAIA;AACE,SAAMG,QAAMA,CAAAC,IAAK,EAAAC,GAAA;EACjB,IAAIC,GAAA,GAAAF,IAAO,CAAAG,WAAW,CAAK;IAAMC,IAAA,GAAOF,GAAA,IAAI,IAAAF,IAAA,CAAAF,KAAA,CAAAI,GAAA,QAAAF,IAAA;EAC5C,OAAIC,GAAA,IAAOG,IAAA,CAAKP,QAAA,CAASI,GAAG,MAAGG,IAAA,GAAOA,IAAA,CAAKN,KAAA,CAAM,GAAG,CAACG,GAAA,CAAII,MAAM,IACxDD,IAAA;AACT;AAIA,SAASE,kBAAkBC,KAAA,EAA+BC,SAAA,EAA6B;EACrF,IAAAC,MAAM,GAAAd,kBAAS,CAAAa,SAAmB,IAAS,GAAI;IAAAE,GACzC,KAAgB;IAACC,yBAAA;IAAAC,iBAAA;IAAAC,cAAA;EACvB;IACE,KAAK,IAAAC,SAAK,GAAWC,MAAM,CAAAC,IAAG,CAAAT,KAAA,EAAAU,MAAA,CAAAC,QAAA,KAAAC,KAAA,IAAAR,yBAAA,IAAAQ,KAAA,GAAAL,SAAA,CAAAM,IAAA,IAAAC,IAAA,GAAAV,yBAAA;MAC9B,IAAMX,IAAA,GAAOmB,KAAK,CAAAhC,KAAM;MAEpB,IAAKa,IAAA,CAAAsB,UAAY,CAChBb,MAAK;QAGZ,IAAAc,IAAA,GAAAvB,IAAA,CAAAF,KAAA,CAAAW,MAAA,CAAAJ,MAAA;QACAkB,IAAO,CAAIC,QAAK,SAAAD,IAAA,CAAA1B,QAAA,YAAA0B,IAAA,CAAA1B,QAAA,aAAAa,GAAA,CAAAe,IAAA,CAAAzB,IAAA;MAClB;IAIO;EACL,SAAQ0B,GAAA;IAIRd,iBAAI,OAAAC,cAAA,GAAAa,GAAA;EACJ,UAAS;IACP;MAAqB,CAChBf,yBAAA,IAAAG,SAAA,CAAAa,MAAA,YAAAb,SAAA,CAAAa,MAAA;IAEL,UAAM;MAEN,IAAAf,iBAD+B,EAEjC,MAAAC,cAAA;IAEA;EAUA;EACE,OAAAH,GAAM,CAAAkB,IAAA;AAUN;AAEA,SAAItC,aAAAuC,IAAgB;EAClB;MAAAtB,KAAA;MAAAuB;IAAY,CACZ,GAAAD,IAAA;IAAAE,OAAA,GAAApC,kBAAmC,CAAAkC,IAAA,CAAAG,GAAA;IAAAC,aAAA;EACnC,IAAAJ,IAAA,CAAAK,SAAW,EACXD,aAAW,GAAAJ,IAAO,CAAAK,SAAA,MAChB;IAEJ,IAAAC,eAAA,MAAAJ,OAAA;MAAAK,eAAA,GAAArB,MAAA,CAAAC,IAAA,CAAAT,KAAA,EAAA8B,IAAA,WAAAC,CAAA;QAWA,OAAMA,CAAA,CAAAhB,UAAU,CAAAa,eAAa;MAI3B;IACEF,aAAS,GAAAG,eAAc,cAAW,GAAQ;EAG5C;EAIA,IAAAG,aAAI,MAAcR,OAAA,IAAAE,aAAA;IAAAO,cAAA,MAAAT,OAAA;IAAAU,cAAA,GAAAnC,iBAAA,CAAAC,KAAA,EAAAgC,aAAA;IAAAG,cAAA,GAAApC,iBAAA,CAAAC,KAAA,EAAAiC,cAAA;IAAAG,iBAAA;IAAAC,oBAAA;IAAAjC,yBAAA;IAAAC,iBAAA;IAAAC,cAAA;EAChB;IAKF,SAAIC,SAAA,GAA6B2B,cAAA,CAAAxB,MAAA,CAAAC,QAAA,KAAAC,KAAA,IAAAR,yBAAA,IAAAQ,KAAA,GAAAL,SAAA,CAAAM,IAAA,IAAAC,IAAA,GAAAV,yBAAA;MACjC,IAAIkC,QAAA,GAAA1B,KAAA,CAAAhC,KAAA;QAAA2D,SAAA,GAAA/C,QAAA,CAAA8C,QAAA;QAAAE,OAAA,GAAAxC,KAAA,CAAAsC,QAAA;QAAAG,MAAA,GAAAlB,KAAA,CAAAiB,OAAA,EAAAF,QAAA;QAAAI,kBAAA;QAAAC,cAAA,IAAAD,kBAAA,GAAAD,MAAA,CAAAG,SAAA,iBAAAF,kBAAA,cAAAA,kBAAA;QAAAG,OAAA;QAAAC,WAAA;QAAAC,SAAA;MACF,IAAAJ,cAAA,EAAcK,MAAA;QAChBD,SAAQ,OAAAV,oBAAA,CAAAnB,IAAA,CAAAqB,SAAA;QACN,IAAAU,0BAAc;UAAAC,kBAAA;UAAAC,eAAA;QAChB;UAEA,KAAO,IAAAC,UAAA,GAAAT,cAAA,CAAAK,MAAA,CAAAF,WAAA,CAAApC,MAAA,CAAAC,QAAA,KAAA0C,MAAA,IAAAJ,0BAAA,IAAAI,MAAA,GAAAD,UAAA,CAAAvC,IAAA,IAAAC,IAAA,GAAAmC,0BAAA;YACL,IAAQK,EAAA,GAAAD,MAAA,CAAAzE,KAAA;YACRkE,WAAA,CAAA5B,IAAA,CAAAoC,EAAA;UACA;QACF,SAAAnC,GAAA;UACD+B,kBAAA,OAAAC,eAAA,GAAAhC,GAAA;QAED;UACE;YACA,CAAA8B,0BAAA,IAAAG,UAAA,CAAAhC,MAAA,YAAAgC,UAAA,CAAAhC,MAAA;UACA;YACA,IAAA8B,kBAAA,EACA,MAAAC,eAAA;UACD;QACH;QAGM,IAAAI,0BAKA;UAAAC,kBAAA;UAAAC,eAAA;QAEN;UACQ,SAAAC,UAAe,GAAAf,cAAmB,CAAAK,MAClC,CAAAH,OAAA,CAAUnC,MAAM,CAAAC,QAAQ,EACxB,GAAAgD,MAAS,IAAAJ,0BAAuB,IAAAI,MAAA,GAAAD,UAAA,CAAA7C,IAAA,IAAAC,IAAA,GAAAyC,0BAAA;YAEtC,IAAWK,GAAA,GAAKD,MAAO,CAAA/E,KAAA;YAEfiE,OAAA,CAAAe,GAAS,CAAAC,IAAA,MAAc,EAAA3E,uBAAA,CAAA4E,eAAA,EAAAF,GAAA,CAAAG,WAAA;UAGzB;QACF,SAAA5C,GAAW;UACTqC,kBAAQ,OAAAC,eAAA,GAAAtC,GAAA;QAAA,UACA;UACR;YACA,CAAAoC,0BAAY,IAAAG,UAAA,CAAAtC,MAAA,YAAAsC,UAAA,CAAAtC,MAAA;UACb;YACD,IAAAoC,kBAAA,EACF,MAAAC,eAAA;UAEA;QAOA;MACA;MACE,IAAAO,OAAA,GAAAjB,SAAc,IAAAJ,cAAA;QAAAsB,wBAAyB;QAAAC,MAAA,KAAAD,wBAAA,GAAAtB,cAAA,EAAAwB,QAAA,cAAAF,wBAAA,cAAAA,wBAAA,OAAAG,GAAA,WAAAC,CAAA;UACzC,IAAAA,CAAA,CAAQC,aAAA,UACN;YACFT,IAAA,EAAAQ,CAAA,CAAAR,IAAA;YAEAU,SAAW,EAAK;YACdC,WAAQ;UACR;UACA,IAAAC,UAAa,GAAAJ,CAAA,CAAAC,aAAe,CAAAI,IAAA;UAC5B,IAAAD,UAAY,gBACb;YACHZ,IAAA,EAAAQ,CAAA,CAAAR,IAAA;YACFU,SAAA;YAGMC,WAAa;UAGf;UAoBA,IAAAG,YAAgB;UACpB;YACQA,YAAS,OAAAzF,uBACf,CAAA0F,eAA0B,EAAAH,UAAA;UACvB,QAAS;YACVE,YAAA;UAGJ;UACE,OAAO;YACPd,IAAA,EAAYQ,CAAA,CAAAR,IAAA;YACZU,SAAY,EAAAE,UAAW;YACvBD,WAAA,EAAAG,YAAA;UACA;QACF;MACFvC,iBAAA,CAAAlB,IAAA","ignoreList":[]}

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

@@ -0,0 +1,229 @@
+var import_vitest = require("vitest"),
+  import_generate_lite = require("./generate-lite.cjs");
+function makeParse(table) {
+  return (_src, path) => {
+    const entry = table[path];
+    if (!entry) throw new Error(`no lite ast fixture for ${path}`);
+    return entry;
+  };
+}
+const DIR = "/proj/src/data";
+(0, import_vitest.describe)("generateLite", () => {
+  (0, import_vitest.test)("emits models.ts, syncedMutations.ts, and README.md from inline types", () => {
+    const 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"]);
+    const 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 = {");
+    const 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", () => {
+    const 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: []
+        }
+      },
+      synced = (0, import_generate_lite.generateLite)({
+        files,
+        dir: DIR,
+        parse: makeParse(fixtures)
+      }).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", () => {
+    const 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();
+    const grouped = result.files["groupedQueries.ts"];
+    (0, import_vitest.expect)(grouped).toContain("export * as post from '../queries/post'");
+    const 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", () => {
+    const 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();
+    const types = result.files["types.ts"];
+    (0, import_vitest.expect)(types).toContain("export type Task = TableInsertRow<typeof schema.task>");
+    const tables = result.files["tables.ts"];
+    (0, import_vitest.expect)(tables).toContain("export { schema as task } from '../models/task'");
+    const 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", () => {
+    const 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);
+    const 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", () => {
+    const files = {
+        [`${DIR}/mutations/post.ts`]: "// fake"
+      },
+      fixtures = {
+        [`${DIR}/mutations/post.ts`]: {
+          mutations: [{
+            modelName: "post",
+            handlers: [{
+              name: "publish",
+              paramTypeText: "{ id: string }"
+            }],
+            schema: null
+          }],
+          queries: []
+        }
+      },
+      models = (0, import_generate_lite.generateLite)({
+        files,
+        dir: DIR,
+        parse: makeParse(fixtures)
+      }).files["models.ts"];
+    (0, import_vitest.expect)(models).toContain("from '../mutations/post'");
+  });
+});