on-zero 0.12.21 → 0.13.0

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

@@ -30,6 +30,11 @@ __export(generate_layout_exports, {
 module.exports = __toCommonJS(generate_layout_exports);
 var import_fs = require("fs");
 var import_path = require("path");
+function _type_of(obj) {
+  "@swc/helpers - typeof";
+
+  return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
 var isSourceFile = function isSourceFile2(name) {
   return name.endsWith(".ts") && !name.endsWith(".d.ts") && !name.endsWith(".test.ts") && !name.endsWith(".spec.ts");
 };
@@ -435,6 +440,82 @@ function namespaceExportKinds(ts, baseDir, path) {
     query
   };
 }
+function mutationTable(ts, path, namespace) {
+  var source = ts.createSourceFile(path, (0, import_fs.readFileSync)(path, "utf8"), ts.ScriptTarget.Latest, true);
+  var schemaTable = null;
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = source.statements[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var statement = _step.value;
+      var _statement_modifiers;
+      if (!ts.isVariableStatement(statement)) continue;
+      if (!((_statement_modifiers = statement.modifiers) === null || _statement_modifiers === void 0 ? void 0 : _statement_modifiers.some(function (modifier) {
+        return modifier.kind === ts.SyntaxKind.ExportKeyword;
+      }))) {
+        continue;
+      }
+      var _iteratorNormalCompletion1 = true,
+        _didIteratorError1 = false,
+        _iteratorError1 = void 0;
+      try {
+        var _loop = function () {
+          var declaration = _step1.value;
+          if (!ts.isIdentifier(declaration.name) || !declaration.initializer) return "continue";
+          if (declaration.name.text === "mutate" && ts.isCallExpression(declaration.initializer)) {
+            var firstArgument = declaration.initializer.arguments[0];
+            if (firstArgument && ts.isStringLiteralLike(firstArgument)) {
+              return {
+                v: firstArgument.text
+              };
+            }
+          }
+          if (declaration.name.text !== "schema") return "continue";
+          var visit = function visit1(node) {
+            if (ts.isCallExpression(node) && node.expression.getText(source) === "table" && node.arguments[0] && ts.isStringLiteralLike(node.arguments[0])) {
+              schemaTable = node.arguments[0].text;
+              return;
+            }
+            ts.forEachChild(node, visit);
+          };
+          visit(declaration.initializer);
+        };
+        for (var _iterator1 = statement.declarationList.declarations[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+          var _ret = _loop();
+          if (_type_of(_ret) === "object") return _ret.v;
+        }
+      } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+            _iterator1.return();
+          }
+        } finally {
+          if (_didIteratorError1) {
+            throw _iteratorError1;
+          }
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return schemaTable !== null && schemaTable !== void 0 ? schemaTable : namespace;
+}
 function discoverNamespaces(ts, baseDir, instance, instanceDirs) {
   var namespaces = [];
   var _iteratorNormalCompletion = true,
@@ -460,6 +541,8 @@ function discoverNamespaces(ts, baseDir, instance, instanceDirs) {
           // a query-only file is not a model, matching the folder layout where a
           // missing mutations.ts leaves modelPath null
           modelPath: kinds.model ? path : null,
+          aggregatePath: null,
+          table: kinds.model ? mutationTable(ts, path, name) : null,
           sourcePaths: [path]
         });
         continue;
@@ -469,9 +552,11 @@ function discoverNamespaces(ts, baseDir, instance, instanceDirs) {
       if (entry.name === "generated" || instanceDirs.has(folder)) continue;
       var queryPath = (0, import_path.resolve)(folder, "queries.ts");
       var modelPath = (0, import_path.resolve)(folder, "mutations.ts");
+      var aggregatePath = (0, import_path.resolve)(folder, "aggregates.ts");
       var hasQueries = (0, import_fs.existsSync)(queryPath);
       var hasMutations = (0, import_fs.existsSync)(modelPath);
-      if (!hasQueries && !hasMutations) {
+      var hasAggregates = (0, import_fs.existsSync)(aggregatePath);
+      if (!hasQueries && !hasMutations && !hasAggregates) {
         if (["models", "mutations", "queries"].includes(entry.name) && (0, import_fs.readdirSync)(folder).some(isSourceFile)) {
           throw new Error(`[on-zero] ${folder} uses the removed top-level ${entry.name}/ layout; move each namespace to <name>.ts or <name>/queries.ts + mutations.ts`);
         }
@@ -482,7 +567,9 @@ function discoverNamespaces(ts, baseDir, instance, instanceDirs) {
         instance: instance.name,
         queryPath: hasQueries ? queryPath : null,
         modelPath: hasMutations ? modelPath : null,
-        sourcePaths: [hasQueries && queryPath, hasMutations && modelPath].filter(function (path2) {
+        aggregatePath: hasAggregates ? aggregatePath : null,
+        table: hasMutations ? mutationTable(ts, modelPath, entry.name) : null,
+        sourcePaths: [hasQueries && queryPath, hasMutations && modelPath, hasAggregates && aggregatePath].filter(function (path2) {
           return Boolean(path2);
         })
       });
@@ -1115,139 +1202,162 @@ function discoverDataLayout(ts, baseDir, configPath) {
       }
     }
   }
-  var tableOwners = new Map(namespaces.filter(function (namespace2) {
-    return namespace2.modelPath !== null;
-  }).map(function (namespace2) {
-    return [namespace2.name, namespace2.instance];
-  }));
+  var tableOwners = /* @__PURE__ */new Map();
+  var _iteratorNormalCompletion2 = true,
+    _didIteratorError2 = false,
+    _iteratorError2 = void 0;
+  try {
+    for (var _iterator2 = namespaces[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+      var namespace1 = _step2.value;
+      if (namespace1.table === null) continue;
+      var owner1 = tableOwners.get(namespace1.table);
+      if (owner1 && owner1 !== namespace1.instance) {
+        throw new Error(`[on-zero] table '${namespace1.table}' is claimed by instances '${owner1}' and '${namespace1.instance}'`);
+      }
+      tableOwners.set(namespace1.table, namespace1.instance);
+    }
+  } catch (err) {
+    _didIteratorError2 = true;
+    _iteratorError2 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+        _iterator2.return();
+      }
+    } finally {
+      if (_didIteratorError2) {
+        throw _iteratorError2;
+      }
+    }
+  }
   var metadata = metadataPaths(baseDir);
   var relations = relationTargets(ts, metadata);
   var columns = tableColumns(ts, metadata, namespaces);
   var relatedOwners = /* @__PURE__ */new Map();
-  var _iteratorNormalCompletion2 = true,
-    _didIteratorError2 = false,
-    _iteratorError2 = void 0;
+  var _iteratorNormalCompletion3 = true,
+    _didIteratorError3 = false,
+    _iteratorError3 = void 0;
   try {
-    for (var _iterator2 = instances[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
-      var instance1 = _step2.value;
-      var tables = new Set(instance1.namespaces.filter(function (namespace2) {
-        return namespace2.modelPath !== null;
-      }).map(function (namespace2) {
-        return namespace2.name;
+    for (var _iterator3 = instances[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+      var instance1 = _step3.value;
+      var tables = new Set(instance1.namespaces.map(function (namespace3) {
+        return namespace3.table;
+      }).filter(function (table2) {
+        return table2 !== null;
       }));
       var syncTables = new Set(tables);
-      var _iteratorNormalCompletion3 = true,
-        _didIteratorError3 = false,
-        _iteratorError3 = void 0;
+      var _iteratorNormalCompletion4 = true,
+        _didIteratorError4 = false,
+        _iteratorError4 = void 0;
       try {
-        for (var _iterator3 = instance1.namespaces[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
-          var namespace1 = _step3.value;
-          var _iteratorNormalCompletion4 = true,
-            _didIteratorError4 = false,
-            _iteratorError4 = void 0;
+        for (var _iterator4 = instance1.namespaces[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+          var namespace2 = _step4.value;
+          var _iteratorNormalCompletion5 = true,
+            _didIteratorError5 = false,
+            _iteratorError5 = void 0;
           try {
-            for (var _iterator4 = queriedTables(ts, namespace1, relations)[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
-              var reached = _step4.value;
+            for (var _iterator5 = queriedTables(ts, namespace2, relations)[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+              var reached = _step5.value;
               var _tableOwners_get;
-              var owner1 = (_tableOwners_get = tableOwners.get(reached.table)) !== null && _tableOwners_get !== void 0 ? _tableOwners_get : relatedOwners.get(reached.table);
-              if (owner1 && owner1 !== instance1.name) {
-                throw new Error(`[on-zero] ${namespace1.name}.${reached.query} in instance '${instance1.name}' reaches table '${reached.table}' owned by instance '${owner1}'`);
+              var owner2 = (_tableOwners_get = tableOwners.get(reached.table)) !== null && _tableOwners_get !== void 0 ? _tableOwners_get : relatedOwners.get(reached.table);
+              if (owner2 && owner2 !== instance1.name) {
+                throw new Error(`[on-zero] ${namespace2.name}.${reached.query} in instance '${instance1.name}' reaches table '${reached.table}' owned by instance '${owner2}'`);
               }
               relatedOwners.set(reached.table, instance1.name);
               if (reached.root) tables.add(reached.table);
               syncTables.add(reached.table);
             }
           } catch (err) {
-            _didIteratorError4 = true;
-            _iteratorError4 = err;
+            _didIteratorError5 = true;
+            _iteratorError5 = err;
           } finally {
             try {
-              if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
-                _iterator4.return();
+              if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
+                _iterator5.return();
               }
             } finally {
-              if (_didIteratorError4) {
-                throw _iteratorError4;
+              if (_didIteratorError5) {
+                throw _iteratorError5;
               }
             }
           }
         }
       } catch (err) {
-        _didIteratorError3 = true;
-        _iteratorError3 = err;
+        _didIteratorError4 = true;
+        _iteratorError4 = err;
       } finally {
         try {
-          if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
-            _iterator3.return();
+          if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+            _iterator4.return();
           }
         } finally {
-          if (_didIteratorError3) {
-            throw _iteratorError3;
+          if (_didIteratorError4) {
+            throw _iteratorError4;
           }
         }
       }
       instance1.tables = [...tables].sort();
       instance1.syncTables = [...syncTables].sort();
       if (instance1.scope) {
-        var _iteratorNormalCompletion5 = true,
-          _didIteratorError5 = false,
-          _iteratorError5 = void 0;
+        var _iteratorNormalCompletion6 = true,
+          _didIteratorError6 = false,
+          _iteratorError6 = void 0;
         try {
-          for (var _iterator5 = instance1.syncTables[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
-            var table = _step5.value;
+          for (var _iterator6 = instance1.syncTables[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
+            var table = _step6.value;
             var _columns_get;
             if (!((_columns_get = columns.get(table)) === null || _columns_get === void 0 ? void 0 : _columns_get.has(instance1.scope))) {
               throw new Error(`[on-zero] table '${table}' in instance '${instance1.name}' is missing scope column '${instance1.scope}'`);
             }
           }
         } catch (err) {
-          _didIteratorError5 = true;
-          _iteratorError5 = err;
+          _didIteratorError6 = true;
+          _iteratorError6 = err;
         } finally {
           try {
-            if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
-              _iterator5.return();
+            if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
+              _iterator6.return();
             }
           } finally {
-            if (_didIteratorError5) {
-              throw _iteratorError5;
+            if (_didIteratorError6) {
+              throw _iteratorError6;
             }
           }
         }
       }
     }
   } catch (err) {
-    _didIteratorError2 = true;
-    _iteratorError2 = err;
+    _didIteratorError3 = true;
+    _iteratorError3 = err;
   } finally {
     try {
-      if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-        _iterator2.return();
+      if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+        _iterator3.return();
       }
     } finally {
-      if (_didIteratorError2) {
-        throw _iteratorError2;
+      if (_didIteratorError3) {
+        throw _iteratorError3;
       }
     }
   }
-  var _iteratorNormalCompletion6 = true,
-    _didIteratorError6 = false,
-    _iteratorError6 = void 0;
+  var _iteratorNormalCompletion7 = true,
+    _didIteratorError7 = false,
+    _iteratorError7 = void 0;
   try {
     var _loop = function () {
-      var instance2 = _step6.value;
+      var instance2 = _step7.value;
       var supportTables = new Set(instance2.declaredSupportTables);
-      var _iteratorNormalCompletion7 = true,
-        _didIteratorError7 = false,
-        _iteratorError7 = void 0;
+      var _iteratorNormalCompletion8 = true,
+        _didIteratorError8 = false,
+        _iteratorError8 = void 0;
       try {
-        for (var _iterator7 = instance2.namespaces[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
-          var namespace2 = _step7.value;
+        for (var _iterator8 = instance2.namespaces[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
+          var namespace3 = _step8.value;
           var _iteratorNormalCompletion12 = true,
             _didIteratorError12 = false,
             _iteratorError12 = void 0;
           try {
-            for (var _iterator12 = mutationSupportTables(ts, baseDir, sourceRoots, namespace2)[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
+            for (var _iterator12 = mutationSupportTables(ts, baseDir, sourceRoots, namespace3)[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
               var table2 = _step12.value;
               if (tableOwners.has(table2) || relatedOwners.has(table2)) continue;
               if (!instance2.syncTables.includes(table2)) {
@@ -1270,16 +1380,16 @@ function discoverDataLayout(ts, baseDir, configPath) {
           }
         }
       } catch (err) {
-        _didIteratorError7 = true;
-        _iteratorError7 = err;
+        _didIteratorError8 = true;
+        _iteratorError8 = err;
       } finally {
         try {
-          if (!_iteratorNormalCompletion7 && _iterator7.return != null) {
-            _iterator7.return();
+          if (!_iteratorNormalCompletion8 && _iterator8.return != null) {
+            _iterator8.return();
           }
         } finally {
-          if (_didIteratorError7) {
-            throw _iteratorError7;
+          if (_didIteratorError8) {
+            throw _iteratorError8;
           }
         }
       }
@@ -1287,18 +1397,18 @@ function discoverDataLayout(ts, baseDir, configPath) {
         return !instance2.syncTables.includes(table3);
       }).sort();
     };
-    for (var _iterator6 = instances[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) _loop();
+    for (var _iterator7 = instances[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) _loop();
   } catch (err) {
-    _didIteratorError6 = true;
-    _iteratorError6 = err;
+    _didIteratorError7 = true;
+    _iteratorError7 = err;
   } finally {
     try {
-      if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
-        _iterator6.return();
+      if (!_iteratorNormalCompletion7 && _iterator7.return != null) {
+        _iterator7.return();
       }
     } finally {
-      if (_didIteratorError6) {
-        throw _iteratorError6;
+      if (_didIteratorError7) {
+        throw _iteratorError7;
       }
     }
   }