on-zero 0.7.10 → 0.8.0

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

@@ -37,6 +37,51 @@ function baseName(path, ext) {
   if (ext && base.endsWith(ext)) base = base.slice(0, -ext.length);
   return base;
 }
+function resolvePath(path) {
+  var absolute = path.startsWith("/");
+  var parts = [];
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = path.split("/")[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var part = _step.value;
+      if (!part || part === ".") continue;
+      if (part === "..") parts.pop();else parts.push(part);
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return `${absolute ? "/" : ""}${parts.join("/")}`;
+}
+function parentDir(path) {
+  return path.slice(0, path.lastIndexOf("/"));
+}
+function relativePath(from, to) {
+  var fromParts = resolvePath(from).split("/").filter(Boolean);
+  var toParts = resolvePath(to).split("/").filter(Boolean);
+  var common = 0;
+  while (fromParts[common] === toParts[common] && common < fromParts.length) common++;
+  return [...Array.from({
+    length: fromParts.length - common
+  }, function () {
+    return "..";
+  }), ...toParts.slice(common)].join("/");
+}
+var isWithin = function isWithin2(root, path) {
+  return path === root || path.startsWith(`${root}/`);
+};
 function listDirectTsFiles(files, dirPrefix) {
   var prefix = stripTrailingSlash(dirPrefix) + "/";
   var out = [];
@@ -70,93 +115,468 @@ function listDirectTsFiles(files, dirPrefix) {
   }
   return out.sort();
 }
+function discoverLiteLayout(files, baseDir, parse, explicitConfigPath) {
+  var paths = Object.keys(files);
+  var configPath = resolvePath(explicitConfigPath !== null && explicitConfigPath !== void 0 ? explicitConfigPath : `${baseDir}/on-zero.config.ts`);
+  var configSource = files[configPath];
+  var config;
+  if (configSource !== void 0) {
+    var parsed = parse(configSource, configPath);
+    if (parsed.parseError) {
+      throw new Error(`[on-zero] unable to parse ${configPath}: ${parsed.parseError}`);
+    }
+    config = parsed.dataConfig;
+    if (!config) {
+      throw new Error(`[on-zero] ${configPath} must default export defineConfig({ instances: { ... } })`);
+    }
+  } else if (explicitConfigPath) {
+    throw new Error(`[on-zero] config file does not exist: ${configPath}`);
+  }
+  if (explicitConfigPath && parentDir(configPath) !== baseDir) {
+    throw new Error(`[on-zero] ${configPath} must be at the data root ${baseDir}`);
+  }
+  var instances = config ? Object.entries(config.instances).map(function (param) {
+    var [name, options] = param;
+    var _options_dir, _options_scope, _options_supportTables;
+    var _options_dir1, _options_supportTables1;
+    if ((_options_dir1 = options.dir) === null || _options_dir1 === void 0 ? void 0 : _options_dir1.startsWith("/")) {
+      throw new Error(`[on-zero] instance '${name}' dir must be relative to ${configPath}`);
+    }
+    if (options.scope === "") {
+      throw new Error(`[on-zero] instance '${name}' scope cannot be empty`);
+    }
+    if ((_options_supportTables1 = options.supportTables) === null || _options_supportTables1 === void 0 ? void 0 : _options_supportTables1.some(function (table) {
+      return table === "";
+    })) {
+      throw new Error(`[on-zero] instance '${name}' supportTables cannot contain an empty table name`);
+    }
+    return {
+      name,
+      dir: resolvePath(`${parentDir(configPath)}/${(_options_dir = options.dir) !== null && _options_dir !== void 0 ? _options_dir : name}`),
+      scope: (_options_scope = options.scope) !== null && _options_scope !== void 0 ? _options_scope : null,
+      declaredSupportTables: [...((_options_supportTables = options.supportTables) !== null && _options_supportTables !== void 0 ? _options_supportTables : [])],
+      namespaces: []
+    };
+  }) : [{
+    name: "default",
+    dir: baseDir,
+    scope: null,
+    declaredSupportTables: [],
+    namespaces: []
+  }];
+  if (config && instances.length === 0) {
+    throw new Error(`[on-zero] ${configPath} must declare at least one instance`);
+  }
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    var _loop = function () {
+      var instance2 = _step.value;
+      if (!paths.some(function (path2) {
+        return isWithin(instance2.dir, path2);
+      })) {
+        throw new Error(`[on-zero] instance '${instance2.name}' directory does not exist: ${instance2.dir}`);
+      }
+      var duplicate = instances.find(function (candidate) {
+        return candidate !== instance2 && candidate.dir === instance2.dir;
+      });
+      if (duplicate) {
+        throw new Error(`[on-zero] instances '${instance2.name}' and '${duplicate.name}' resolve to the same directory: ${instance2.dir}`);
+      }
+    };
+    for (var _iterator = instances[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) _loop();
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  var instanceDirs = new Set(instances.map(function (instance2) {
+    return instance2.dir;
+  }));
+  var sourceRoots = [baseDir, ...instances.map(function (instance2) {
+    return instance2.dir;
+  })];
+  var remnant = paths.find(function (path2) {
+    return baseName(path2) === "instance.ts" && sourceRoots.some(function (root) {
+      return isWithin(root, path2);
+    });
+  });
+  if (remnant) {
+    throw new Error(`[on-zero] ${remnant} uses removed instance.ts configuration; delete it and configure instances in on-zero.config.ts`);
+  }
+  var parseDataFile = function parseDataFile2(path2) {
+    var parsed2;
+    try {
+      parsed2 = parse(files[path2], path2);
+    } catch (unused) {
+      console.warn(`[on-zero] ignoring ${path2.slice(baseDir.lastIndexOf("/") + 1)}: no recognized data exports`);
+      return null;
+    }
+    if (parsed2.parseError) {
+      console.warn(`[on-zero] ignoring ${path2.slice(baseDir.lastIndexOf("/") + 1)}: no recognized data exports`);
+      return null;
+    }
+    return parsed2;
+  };
+  var hasDataExport = function hasDataExport2(source2, parsed2) {
+    var _ref;
+    var _parsed_tables;
+    return parsed2.queries.length > 0 || parsed2.mutations.length > 0 || ((_ref = (_parsed_tables = parsed2.tables) === null || _parsed_tables === void 0 ? void 0 : _parsed_tables.length) !== null && _ref !== void 0 ? _ref : 0) > 0 || /export\s+const\s+(?:mutate|schema|where)\s*=\s*(?:mutations|serverWhere|table)\s*\(/.test(source2);
+  };
+  if (config) {
+    var _iteratorNormalCompletion1 = true,
+      _didIteratorError1 = false,
+      _iteratorError1 = void 0;
+    try {
+      var _loop1 = function () {
+        var path2 = _step1.value;
+        if (path2 === configPath || !isWithin(baseDir, path2) || instances.some(function (instance2) {
+          return isWithin(instance2.dir, path2);
+        }) || isWithin(`${baseDir}/generated`, path2) || !path2.endsWith(".ts") || path2.endsWith(".d.ts") || path2.endsWith(".test.ts") || path2.endsWith(".spec.ts") || baseName(path2) === "instance.ts") {
+          return "continue";
+        }
+        var parsed2 = parseDataFile(path2);
+        if (parsed2 && hasDataExport(files[path2], parsed2)) {
+          throw new Error(`[on-zero] data namespace ${path2} is outside every instance directory declared in ${configPath}`);
+        }
+      };
+      for (var _iterator1 = paths[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) _loop1();
+    } catch (err) {
+      _didIteratorError1 = true;
+      _iteratorError1 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+          _iterator1.return();
+        }
+      } finally {
+        if (_didIteratorError1) {
+          throw _iteratorError1;
+        }
+      }
+    }
+  }
+  var _iteratorNormalCompletion2 = true,
+    _didIteratorError2 = false,
+    _iteratorError2 = void 0;
+  try {
+    for (var _iterator2 = instances[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+      var instance = _step2.value;
+      var directFiles = listDirectTsFiles(files, instance.dir).filter(function (path2) {
+        return baseName(path2) !== "on-zero.config.ts";
+      });
+      var _iteratorNormalCompletion3 = true,
+        _didIteratorError3 = false,
+        _iteratorError3 = void 0;
+      try {
+        for (var _iterator3 = directFiles[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+          var path = _step3.value;
+          var source = files[path];
+          var parsed1 = parseDataFile(path);
+          if (!parsed1 || !hasDataExport(source, parsed1)) continue;
+          instance.namespaces.push({
+            name: baseName(path, ".ts"),
+            instance: instance.name,
+            queryPath: path,
+            modelPath: path
+          });
+        }
+      } catch (err) {
+        _didIteratorError3 = true;
+        _iteratorError3 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+            _iterator3.return();
+          }
+        } finally {
+          if (_didIteratorError3) {
+            throw _iteratorError3;
+          }
+        }
+      }
+      var prefix = `${instance.dir}/`;
+      var folders = /* @__PURE__ */new Set();
+      var _iteratorNormalCompletion4 = true,
+        _didIteratorError4 = false,
+        _iteratorError4 = void 0;
+      try {
+        for (var _iterator4 = paths[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+          var path1 = _step4.value;
+          if (!path1.startsWith(prefix)) continue;
+          var rest = path1.slice(prefix.length);
+          var slash = rest.indexOf("/");
+          if (slash > 0) folders.add(`${instance.dir}/${rest.slice(0, slash)}`);
+        }
+      } catch (err) {
+        _didIteratorError4 = true;
+        _iteratorError4 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+            _iterator4.return();
+          }
+        } finally {
+          if (_didIteratorError4) {
+            throw _iteratorError4;
+          }
+        }
+      }
+      var _iteratorNormalCompletion5 = true,
+        _didIteratorError5 = false,
+        _iteratorError5 = void 0;
+      try {
+        for (var _iterator5 = [...folders].sort()[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+          var folder = _step5.value;
+          if (folder === `${baseDir}/generated` || instanceDirs.has(folder)) continue;
+          var queries = `${folder}/queries.ts`;
+          var mutations = `${folder}/mutations.ts`;
+          if (!(queries in files) && !(mutations in files)) {
+            var oldName = baseName(folder);
+            if (["models", "mutations", "queries"].includes(oldName) && listDirectTsFiles(files, folder).length > 0) {
+              throw new Error(`[on-zero] ${folder} uses the removed top-level ${oldName}/ layout; move each namespace to <name>.ts or <name>/queries.ts + mutations.ts`);
+            }
+            continue;
+          }
+          instance.namespaces.push({
+            name: baseName(folder),
+            instance: instance.name,
+            queryPath: queries in files ? queries : null,
+            modelPath: mutations in files ? mutations : null
+          });
+        }
+      } catch (err) {
+        _didIteratorError5 = true;
+        _iteratorError5 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
+            _iterator5.return();
+          }
+        } finally {
+          if (_didIteratorError5) {
+            throw _iteratorError5;
+          }
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError2 = true;
+    _iteratorError2 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+        _iterator2.return();
+      }
+    } finally {
+      if (_didIteratorError2) {
+        throw _iteratorError2;
+      }
+    }
+  }
+  var owners = /* @__PURE__ */new Map();
+  var _iteratorNormalCompletion6 = true,
+    _didIteratorError6 = false,
+    _iteratorError6 = void 0;
+  try {
+    for (var _iterator6 = instances.flatMap(function (instance2) {
+        return instance2.namespaces;
+      })[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
+      var namespace = _step6.value;
+      var owner = owners.get(namespace.name);
+      if (owner) {
+        throw new Error(`[on-zero] namespace '${namespace.name}' is claimed by instances '${owner}' and '${namespace.instance}'`);
+      }
+      owners.set(namespace.name, namespace.instance);
+    }
+  } catch (err) {
+    _didIteratorError6 = true;
+    _iteratorError6 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
+        _iterator6.return();
+      }
+    } finally {
+      if (_didIteratorError6) {
+        throw _iteratorError6;
+      }
+    }
+  }
+  return instances;
+}
 function generateLite(opts) {
   var {
     files,
     parse
   } = opts;
-  var baseDir = stripTrailingSlash(opts.dir);
-  var modelsDirName;
-  if (opts.modelsDir) {
-    modelsDirName = opts.modelsDir;
-  } else {
-    var mutationsPrefix = `${baseDir}/mutations/`;
-    var hasMutationsDir = Object.keys(files).some(function (p) {
-      return p.startsWith(mutationsPrefix);
-    });
-    modelsDirName = hasMutationsDir ? "mutations" : "models";
-  }
-  var modelsDirPath = `${baseDir}/${modelsDirName}`;
-  var queriesDirPath = `${baseDir}/queries`;
-  var modelFilePaths = listDirectTsFiles(files, modelsDirPath);
-  var queryFilePaths = listDirectTsFiles(files, queriesDirPath);
-  var allModelMutations = [];
-  var modelNamesWithSchema = [];
+  var baseDir = resolvePath(stripTrailingSlash(opts.dir));
+  var instances = discoverLiteLayout(files, baseDir, parse, opts.config);
+  var sourceRoots = [baseDir, ...instances.map(function (instance2) {
+    return instance2.dir;
+  })];
+  var namespaces = instances.flatMap(function (instance2) {
+    return instance2.namespaces;
+  });
+  var modelNamespaces = namespaces.filter(function (namespace3) {
+    return namespace3.modelPath !== null;
+  });
+  var relations = /* @__PURE__ */new Map();
+  var tableColumns = /* @__PURE__ */new Map();
   var _iteratorNormalCompletion = true,
     _didIteratorError = false,
     _iteratorError = void 0;
   try {
-    for (var _iterator = modelFilePaths[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-      var filePath = _step.value;
-      var modelName = baseName(filePath, ".ts");
+    for (var _iterator = Object.keys(files).filter(function (path2) {
+        return path2.endsWith("/relations.ts") || /\/database\/(?:schema[^/]*|zeroSchemaInput)\.ts$/.test(path2);
+      })[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var path = _step.value;
+      var _parsed_relations, _parsed_tables;
+      var parsed = parse(files[path], path);
+      var _iteratorNormalCompletion1 = true,
+        _didIteratorError1 = false,
+        _iteratorError1 = void 0;
+      try {
+        for (var _iterator1 = ((_parsed_relations = parsed.relations) !== null && _parsed_relations !== void 0 ? _parsed_relations : [])[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+          var relation = _step1.value;
+          var _relations_get;
+          var tableRelations = (_relations_get = relations.get(relation.sourceTable)) !== null && _relations_get !== void 0 ? _relations_get : /* @__PURE__ */new Map();
+          tableRelations.set(relation.name, relation.targetTable);
+          relations.set(relation.sourceTable, tableRelations);
+        }
+      } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+            _iterator1.return();
+          }
+        } finally {
+          if (_didIteratorError1) {
+            throw _iteratorError1;
+          }
+        }
+      }
+      var _iteratorNormalCompletion2 = true,
+        _didIteratorError2 = false,
+        _iteratorError2 = void 0;
+      try {
+        for (var _iterator2 = ((_parsed_tables = parsed.tables) !== null && _parsed_tables !== void 0 ? _parsed_tables : [])[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+          var table = _step2.value;
+          tableColumns.set(table.name, new Set(table.columns));
+        }
+      } catch (err) {
+        _didIteratorError2 = true;
+        _iteratorError2 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+            _iterator2.return();
+          }
+        } finally {
+          if (_didIteratorError2) {
+            throw _iteratorError2;
+          }
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  var allModelMutations = [];
+  var modelNamesWithSchema = [];
+  var _iteratorNormalCompletion3 = true,
+    _didIteratorError3 = false,
+    _iteratorError3 = void 0;
+  try {
+    for (var _iterator3 = modelNamespaces[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+      var namespace = _step3.value;
+      var _parsed_mutations_, _ref;
+      var filePath = namespace.modelPath;
+      var modelName = namespace.name;
       var content = files[filePath];
-      var parsed = parse(content, filePath);
-      var _parsed_mutations_;
-      var mutationExport = (_parsed_mutations_ = parsed.mutations[0]) !== null && _parsed_mutations_ !== void 0 ? _parsed_mutations_ : null;
+      var parsed1 = parse(content, filePath);
+      var mutationExport = (_parsed_mutations_ = parsed1.mutations[0]) !== null && _parsed_mutations_ !== void 0 ? _parsed_mutations_ : null;
       var columns = {};
       var primaryKeys = [];
       var hasSchema = false;
       if (mutationExport === null || mutationExport === void 0 ? void 0 : mutationExport.schema) {
         hasSchema = true;
         modelNamesWithSchema.push(modelName);
-        var _iteratorNormalCompletion1 = true,
-          _didIteratorError1 = false,
-          _iteratorError1 = void 0;
+        var _iteratorNormalCompletion4 = true,
+          _didIteratorError4 = false,
+          _iteratorError4 = void 0;
         try {
-          for (var _iterator1 = mutationExport.schema.primaryKeys[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
-            var pk = _step1.value;
+          for (var _iterator4 = mutationExport.schema.primaryKeys[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+            var pk = _step4.value;
             primaryKeys.push(pk);
           }
         } catch (err) {
-          _didIteratorError1 = true;
-          _iteratorError1 = err;
+          _didIteratorError4 = true;
+          _iteratorError4 = err;
         } finally {
           try {
-            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
-              _iterator1.return();
+            if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+              _iterator4.return();
             }
           } finally {
-            if (_didIteratorError1) {
-              throw _iteratorError1;
+            if (_didIteratorError4) {
+              throw _iteratorError4;
             }
           }
         }
-        var _iteratorNormalCompletion2 = true,
-          _didIteratorError2 = false,
-          _iteratorError2 = void 0;
+        var _iteratorNormalCompletion5 = true,
+          _didIteratorError5 = false,
+          _iteratorError5 = void 0;
         try {
-          for (var _iterator2 = mutationExport.schema.columns[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
-            var col = _step2.value;
+          for (var _iterator5 = mutationExport.schema.columns[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+            var col = _step5.value;
             columns[col.name] = (0, import_generate_helpers.parseColumnType)(col.builderText);
           }
         } catch (err) {
-          _didIteratorError2 = true;
-          _iteratorError2 = err;
+          _didIteratorError5 = true;
+          _iteratorError5 = err;
         } finally {
           try {
-            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-              _iterator2.return();
+            if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
+              _iterator5.return();
             }
           } finally {
-            if (_didIteratorError2) {
-              throw _iteratorError2;
+            if (_didIteratorError5) {
+              throw _iteratorError5;
             }
           }
         }
+        var names = new Set(mutationExport.schema.columns.map(function (column) {
+          return column.name;
+        }));
+        tableColumns.set(modelName, names);
+        tableColumns.set(mutationExport.schema.tableName, names);
       }
       var hasCRUD = hasSchema && mutationExport !== null;
-      var _mutationExport_handlers;
-      var custom = ((_mutationExport_handlers = mutationExport === null || mutationExport === void 0 ? void 0 : mutationExport.handlers) !== null && _mutationExport_handlers !== void 0 ? _mutationExport_handlers : []).map(function (h) {
+      var custom = ((_ref = mutationExport === null || mutationExport === void 0 ? void 0 : mutationExport.handlers) !== null && _ref !== void 0 ? _ref : []).map(function (h) {
         if (h.paramTypeText == null) {
           return {
             name: h.name,
@@ -175,7 +595,7 @@ function generateLite(opts) {
         var valibotCode2 = null;
         try {
           valibotCode2 = (0, import_generate_helpers.parseTypeString)(paramType2);
-        } catch (e) {
+        } catch (unused) {
           valibotCode2 = null;
         }
         return {
@@ -193,42 +613,62 @@ function generateLite(opts) {
       });
     }
   } catch (err) {
-    _didIteratorError = true;
-    _iteratorError = err;
+    _didIteratorError3 = true;
+    _iteratorError3 = err;
   } finally {
     try {
-      if (!_iteratorNormalCompletion && _iterator.return != null) {
-        _iterator.return();
+      if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+        _iterator3.return();
       }
     } finally {
-      if (_didIteratorError) {
-        throw _iteratorError;
+      if (_didIteratorError3) {
+        throw _iteratorError3;
       }
     }
   }
   var allQueries = [];
-  var _iteratorNormalCompletion3 = true,
-    _didIteratorError3 = false,
-    _iteratorError3 = void 0;
+  var relatedPaths = /* @__PURE__ */new Map();
+  var _iteratorNormalCompletion6 = true,
+    _didIteratorError6 = false,
+    _iteratorError6 = void 0;
   try {
-    for (var _iterator3 = queryFilePaths[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
-      var filePath1 = _step3.value;
-      var fileBaseName = baseName(filePath1, ".ts");
+    for (var _iterator6 = namespaces.filter(function (namespace3) {
+        return namespace3.queryPath !== null;
+      })[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
+      var namespace1 = _step6.value;
+      var filePath1 = namespace1.queryPath;
+      var fileBaseName = namespace1.name;
       var content1 = files[filePath1];
-      var parsed1 = parse(content1, filePath1);
-      var _iteratorNormalCompletion4 = true,
-        _didIteratorError4 = false,
-        _iteratorError4 = void 0;
+      var parsed2 = parse(content1, filePath1);
+      if (content1.includes(".related(") && !parsed2.queries.some(function (query2) {
+        return query2.relatedPaths;
+      })) {
+        throw new Error(`[on-zero] ${filePath1} uses related(), but the lite parser did not return relatedPaths`);
+      }
+      var _iteratorNormalCompletion7 = true,
+        _didIteratorError7 = false,
+        _iteratorError7 = void 0;
       try {
-        for (var _iterator4 = parsed1.queries[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
-          var q = _step4.value;
-          if (q.name === "permission") continue;
+        for (var _iterator7 = parsed2.queries[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
+          var q = _step7.value;
+          var _q_relatedPaths;
+          if (["mutate", "permission", "schema", "where"].includes(q.name)) continue;
+          if ((_q_relatedPaths = q.relatedPaths) === null || _q_relatedPaths === void 0 ? void 0 : _q_relatedPaths.length) {
+            var _relatedPaths_get;
+            var entries = (_relatedPaths_get = relatedPaths.get(namespace1.name)) !== null && _relatedPaths_get !== void 0 ? _relatedPaths_get : [];
+            entries.push({
+              query: q.name,
+              paths: q.relatedPaths
+            });
+            relatedPaths.set(namespace1.name, entries);
+          }
           if (q.paramTypeText == null) {
             allQueries.push({
               name: q.name,
               params: "void",
               valibotCode: "",
-              sourceFile: fileBaseName
+              sourceFile: fileBaseName,
+              importPath: `../${relativePath(baseDir, filePath1).replace(/\.ts$/, "")}`
             });
             continue;
           }
@@ -236,91 +676,403 @@ function generateLite(opts) {
           var valibotCode = null;
           try {
             valibotCode = (0, import_generate_helpers.parseTypeString)(paramType);
-          } catch (e) {
+          } catch (unused) {
             valibotCode = null;
           }
           allQueries.push({
             name: q.name,
             params: paramType,
             valibotCode: valibotCode !== null && valibotCode !== void 0 ? valibotCode : "v.unknown()",
-            sourceFile: fileBaseName
+            sourceFile: fileBaseName,
+            importPath: `../${relativePath(baseDir, filePath1).replace(/\.ts$/, "")}`
           });
         }
       } catch (err) {
-        _didIteratorError4 = true;
-        _iteratorError4 = err;
+        _didIteratorError7 = true;
+        _iteratorError7 = err;
       } finally {
         try {
-          if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
-            _iterator4.return();
+          if (!_iteratorNormalCompletion7 && _iterator7.return != null) {
+            _iterator7.return();
           }
         } finally {
-          if (_didIteratorError4) {
-            throw _iteratorError4;
+          if (_didIteratorError7) {
+            throw _iteratorError7;
           }
         }
       }
     }
   } catch (err) {
-    _didIteratorError3 = true;
-    _iteratorError3 = err;
+    _didIteratorError6 = true;
+    _iteratorError6 = err;
   } finally {
     try {
-      if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
-        _iterator3.return();
+      if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
+        _iterator6.return();
       }
     } finally {
-      if (_didIteratorError3) {
-        throw _iteratorError3;
+      if (_didIteratorError6) {
+        throw _iteratorError6;
+      }
+    }
+  }
+  var owners = new Map(namespaces.map(function (namespace3) {
+    return [namespace3.name, namespace3.instance];
+  }));
+  var relatedOwners = /* @__PURE__ */new Map();
+  var syncTables = /* @__PURE__ */new Map();
+  var _iteratorNormalCompletion8 = true,
+    _didIteratorError8 = false,
+    _iteratorError8 = void 0;
+  try {
+    for (var _iterator8 = instances[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
+      var instance = _step8.value;
+      var synced = new Set(instance.namespaces.map(function (namespace3) {
+        return namespace3.name;
+      }));
+      var _iteratorNormalCompletion9 = true,
+        _didIteratorError9 = false,
+        _iteratorError9 = void 0;
+      try {
+        for (var _iterator9 = instance.namespaces[Symbol.iterator](), _step9; !(_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done); _iteratorNormalCompletion9 = true) {
+          var namespace2 = _step9.value;
+          var _relatedPaths_get1;
+          var _iteratorNormalCompletion10 = true,
+            _didIteratorError10 = false,
+            _iteratorError10 = void 0;
+          try {
+            for (var _iterator10 = ((_relatedPaths_get1 = relatedPaths.get(namespace2.name)) !== null && _relatedPaths_get1 !== void 0 ? _relatedPaths_get1 : [])[Symbol.iterator](), _step10; !(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done); _iteratorNormalCompletion10 = true) {
+              var query = _step10.value;
+              var _iteratorNormalCompletion11 = true,
+                _didIteratorError11 = false,
+                _iteratorError11 = void 0;
+              try {
+                for (var _iterator11 = query.paths[Symbol.iterator](), _step11; !(_iteratorNormalCompletion11 = (_step11 = _iterator11.next()).done); _iteratorNormalCompletion11 = true) {
+                  var path1 = _step11.value;
+                  var sourceTable = namespace2.name;
+                  var _iteratorNormalCompletion12 = true,
+                    _didIteratorError12 = false,
+                    _iteratorError12 = void 0;
+                  try {
+                    for (var _iterator12 = path1[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
+                      var relationName = _step12.value;
+                      var _owners_get;
+                      var _relations_get1;
+                      var target = (_relations_get1 = relations.get(sourceTable)) === null || _relations_get1 === void 0 ? void 0 : _relations_get1.get(relationName);
+                      if (!target) {
+                        throw new Error(`[on-zero] ${namespace2.name}.${query.query} related('${relationName}') cannot be resolved from table '${sourceTable}' through relations.ts`);
+                      }
+                      var owner = (_owners_get = owners.get(target)) !== null && _owners_get !== void 0 ? _owners_get : relatedOwners.get(target);
+                      if (owner && owner !== instance.name) {
+                        throw new Error(`[on-zero] ${namespace2.name}.${query.query} in instance '${instance.name}' reaches table '${target}' owned by instance '${owner}'`);
+                      }
+                      relatedOwners.set(target, instance.name);
+                      synced.add(target);
+                      sourceTable = target;
+                    }
+                  } catch (err) {
+                    _didIteratorError12 = true;
+                    _iteratorError12 = err;
+                  } finally {
+                    try {
+                      if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
+                        _iterator12.return();
+                      }
+                    } finally {
+                      if (_didIteratorError12) {
+                        throw _iteratorError12;
+                      }
+                    }
+                  }
+                }
+              } catch (err) {
+                _didIteratorError11 = true;
+                _iteratorError11 = err;
+              } finally {
+                try {
+                  if (!_iteratorNormalCompletion11 && _iterator11.return != null) {
+                    _iterator11.return();
+                  }
+                } finally {
+                  if (_didIteratorError11) {
+                    throw _iteratorError11;
+                  }
+                }
+              }
+            }
+          } catch (err) {
+            _didIteratorError10 = true;
+            _iteratorError10 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion10 && _iterator10.return != null) {
+                _iterator10.return();
+              }
+            } finally {
+              if (_didIteratorError10) {
+                throw _iteratorError10;
+              }
+            }
+          }
+        }
+      } catch (err) {
+        _didIteratorError9 = true;
+        _iteratorError9 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion9 && _iterator9.return != null) {
+            _iterator9.return();
+          }
+        } finally {
+          if (_didIteratorError9) {
+            throw _iteratorError9;
+          }
+        }
+      }
+      var tables = [...synced].sort();
+      if (instance.scope) {
+        var _iteratorNormalCompletion13 = true,
+          _didIteratorError13 = false,
+          _iteratorError13 = void 0;
+        try {
+          for (var _iterator13 = tables[Symbol.iterator](), _step13; !(_iteratorNormalCompletion13 = (_step13 = _iterator13.next()).done); _iteratorNormalCompletion13 = true) {
+            var table1 = _step13.value;
+            var _tableColumns_get;
+            if (!((_tableColumns_get = tableColumns.get(table1)) === null || _tableColumns_get === void 0 ? void 0 : _tableColumns_get.has(instance.scope))) {
+              throw new Error(`[on-zero] table '${table1}' in instance '${instance.name}' is missing scope column '${instance.scope}'`);
+            }
+          }
+        } catch (err) {
+          _didIteratorError13 = true;
+          _iteratorError13 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion13 && _iterator13.return != null) {
+              _iterator13.return();
+            }
+          } finally {
+            if (_didIteratorError13) {
+              throw _iteratorError13;
+            }
+          }
+        }
+      }
+      syncTables.set(instance.name, tables);
+    }
+  } catch (err) {
+    _didIteratorError8 = true;
+    _iteratorError8 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion8 && _iterator8.return != null) {
+        _iterator8.return();
+      }
+    } finally {
+      if (_didIteratorError8) {
+        throw _iteratorError8;
+      }
+    }
+  }
+  var supportTables = /* @__PURE__ */new Map();
+  var _iteratorNormalCompletion14 = true,
+    _didIteratorError14 = false,
+    _iteratorError14 = void 0;
+  try {
+    var _loop = function () {
+      var instance2 = _step14.value;
+      var supported = new Set(instance2.declaredSupportTables);
+      var _iteratorNormalCompletion16 = true,
+        _didIteratorError16 = false,
+        _iteratorError16 = void 0;
+      try {
+        var _loop2 = function () {
+          var namespace3 = _step16.value;
+          if (!namespace3.modelPath) return "continue";
+          var visited = /* @__PURE__ */new Set();
+          var scan = function scan1(path2) {
+            var _parsed_supportTables, _parsed_imports;
+            if (visited.has(path2)) return;
+            visited.add(path2);
+            var parsed3 = parse(files[path2], path2);
+            if (parsed3.parseError) {
+              throw new Error(`[on-zero] unable to derive mutation dependencies from ${path2}: ${parsed3.parseError}`);
+            }
+            var _iteratorNormalCompletion17 = true,
+              _didIteratorError17 = false,
+              _iteratorError17 = void 0;
+            try {
+              for (var _iterator17 = ((_parsed_supportTables = parsed3.supportTables) !== null && _parsed_supportTables !== void 0 ? _parsed_supportTables : [])[Symbol.iterator](), _step17; !(_iteratorNormalCompletion17 = (_step17 = _iterator17.next()).done); _iteratorNormalCompletion17 = true) {
+                var table2 = _step17.value;
+                if (owners.has(table2) || relatedOwners.has(table2)) continue;
+                if (!syncTables.get(instance2.name).includes(table2)) {
+                  supported.add(table2);
+                }
+              }
+            } catch (err) {
+              _didIteratorError17 = true;
+              _iteratorError17 = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion17 && _iterator17.return != null) {
+                  _iterator17.return();
+                }
+              } finally {
+                if (_didIteratorError17) {
+                  throw _iteratorError17;
+                }
+              }
+            }
+            var _iteratorNormalCompletion18 = true,
+              _didIteratorError18 = false,
+              _iteratorError18 = void 0;
+            try {
+              for (var _iterator18 = ((_parsed_imports = parsed3.imports) !== null && _parsed_imports !== void 0 ? _parsed_imports : [])[Symbol.iterator](), _step18; !(_iteratorNormalCompletion18 = (_step18 = _iterator18.next()).done); _iteratorNormalCompletion18 = true) {
+                var specifier = _step18.value;
+                var unresolved = specifier.startsWith("~/data/") ? `${baseDir}/${specifier.slice("~/data/".length)}` : specifier.startsWith(".") ? `${parentDir(path2)}/${specifier}` : null;
+                if (!unresolved) continue;
+                var normalized = resolvePath(unresolved);
+                var dependency = [normalized.endsWith(".ts") ? normalized : `${normalized}.ts`, `${normalized}/index.ts`].find(function (candidate) {
+                  return candidate in files && sourceRoots.some(function (root) {
+                    return isWithin(root, candidate);
+                  });
+                });
+                if (dependency) scan(dependency);
+              }
+            } catch (err) {
+              _didIteratorError18 = true;
+              _iteratorError18 = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion18 && _iterator18.return != null) {
+                  _iterator18.return();
+                }
+              } finally {
+                if (_didIteratorError18) {
+                  throw _iteratorError18;
+                }
+              }
+            }
+          };
+          scan(namespace3.modelPath);
+        };
+        for (var _iterator16 = instance2.namespaces[Symbol.iterator](), _step16; !(_iteratorNormalCompletion16 = (_step16 = _iterator16.next()).done); _iteratorNormalCompletion16 = true) _loop2();
+      } catch (err) {
+        _didIteratorError16 = true;
+        _iteratorError16 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion16 && _iterator16.return != null) {
+            _iterator16.return();
+          }
+        } finally {
+          if (_didIteratorError16) {
+            throw _iteratorError16;
+          }
+        }
+      }
+      supportTables.set(instance2.name, [...supported].sort());
+    };
+    for (var _iterator14 = instances[Symbol.iterator](), _step14; !(_iteratorNormalCompletion14 = (_step14 = _iterator14.next()).done); _iteratorNormalCompletion14 = true) _loop();
+  } catch (err) {
+    _didIteratorError14 = true;
+    _iteratorError14 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion14 && _iterator14.return != null) {
+        _iterator14.return();
+      }
+    } finally {
+      if (_didIteratorError14) {
+        throw _iteratorError14;
       }
     }
   }
-  var modelNames = modelFilePaths.map(function (p) {
-    return baseName(p, ".ts");
+  var modelNames = modelNamespaces.map(function (namespace3) {
+    return namespace3.name;
   });
   var out = {};
-  out["models.ts"] = (0, import_generate_helpers.generateModelsFile)(modelNames, modelsDirName);
+  out["models.ts"] = (0, import_generate_helpers.generateModelsFile)(modelNamespaces.map(function (namespace3) {
+    return {
+      name: namespace3.name,
+      importPath: `../${relativePath(baseDir, namespace3.modelPath).replace(/\.ts$/, "")}`
+    };
+  }));
   if (modelNamesWithSchema.length > 0) {
     out["types.ts"] = (0, import_generate_helpers.generateTypesFile)(modelNamesWithSchema);
-    out["tables.ts"] = (0, import_generate_helpers.generateTablesFile)(modelNamesWithSchema, modelsDirName);
+    out["tables.ts"] = (0, import_generate_helpers.generateTablesFile)(modelNamespaces.filter(function (namespace3) {
+      return modelNamesWithSchema.includes(namespace3.name);
+    }).map(function (namespace3) {
+      return {
+        name: namespace3.name,
+        importPath: `../${relativePath(baseDir, namespace3.modelPath).replace(/\.ts$/, "")}`
+      };
+    }));
   }
   out["README.md"] = (0, import_generate_helpers.generateReadmeFile)();
-  if (queryFilePaths.length > 0) {
-    out["groupedQueries.ts"] = (0, import_generate_helpers.generateGroupedQueriesFile)(allQueries);
-    out["syncedQueries.ts"] = (0, import_generate_helpers.generateSyncedQueriesFile)(allQueries);
-  }
+  out["groupedQueries.ts"] = (0, import_generate_helpers.generateGroupedQueriesFile)(allQueries);
+  out["syncedQueries.ts"] = (0, import_generate_helpers.generateSyncedQueriesFile)(allQueries);
+  out["instances.ts"] = (0, import_generate_helpers.generateInstancesFile)(instances.map(function (instance2) {
+    return {
+      name: instance2.name,
+      scope: instance2.scope,
+      queryNames: instance2.namespaces.map(function (namespace3) {
+        return namespace3.name;
+      }).filter(function (name) {
+        return allQueries.some(function (query2) {
+          return query2.sourceFile === name;
+        });
+      }),
+      modelNames: instance2.namespaces.filter(function (namespace3) {
+        return namespace3.modelPath;
+      }).map(function (namespace3) {
+        return namespace3.name;
+      }),
+      tables: instance2.namespaces.map(function (namespace3) {
+        return namespace3.name;
+      }),
+      syncTables: syncTables.get(instance2.name),
+      supportTables: supportTables.get(instance2.name)
+    };
+  }));
   if (allModelMutations.length > 0) {
     out["syncedMutations.ts"] = (0, import_generate_helpers.generateSyncedMutationsFile)(allModelMutations);
   }
   var mutationCount = 0;
-  var _iteratorNormalCompletion5 = true,
-    _didIteratorError5 = false,
-    _iteratorError5 = void 0;
+  var _iteratorNormalCompletion15 = true,
+    _didIteratorError15 = false,
+    _iteratorError15 = void 0;
   try {
-    var _loop = function () {
-      var m = _step5.value;
+    var _loop1 = function () {
+      var m = _step15.value;
       if (m.hasCRUD) mutationCount += 3;
       mutationCount += m.custom.filter(function (mut) {
         return !m.hasCRUD || !["insert", "update", "delete", "upsert"].includes(mut.name);
       }).length;
     };
-    for (var _iterator5 = allModelMutations[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) _loop();
+    for (var _iterator15 = allModelMutations[Symbol.iterator](), _step15; !(_iteratorNormalCompletion15 = (_step15 = _iterator15.next()).done); _iteratorNormalCompletion15 = true) _loop1();
   } catch (err) {
-    _didIteratorError5 = true;
-    _iteratorError5 = err;
+    _didIteratorError15 = true;
+    _iteratorError15 = err;
   } finally {
     try {
-      if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
-        _iterator5.return();
+      if (!_iteratorNormalCompletion15 && _iterator15.return != null) {
+        _iterator15.return();
       }
     } finally {
-      if (_didIteratorError5) {
-        throw _iteratorError5;
+      if (_didIteratorError15) {
+        throw _iteratorError15;
       }
     }
   }
   return {
     files: out,
+    instances: instances.map(function (instance2) {
+      return {
+        name: instance2.name,
+        syncTables: syncTables.get(instance2.name),
+        supportTables: supportTables.get(instance2.name)
+      };
+    }),
     modelCount: modelNames.length,
     queryCount: allQueries.length,
     mutationCount,