@zenstackhq/language 3.0.0-beta.2 → 3.0.0-beta.21

package/dist/utils.cjs

@@ -40,6 +40,7 @@ __export(utils_exports, {
   getAllLoadedAndReachableDataModelsAndTypeDefs: () => getAllLoadedAndReachableDataModelsAndTypeDefs,
   getAllLoadedDataModelsAndTypeDefs: () => getAllLoadedDataModelsAndTypeDefs,
   getAttribute: () => getAttribute,
+  getAttributeArg: () => getAttributeArg,
   getAttributeArgLiteral: () => getAttributeArgLiteral,
   getAuthDecl: () => getAuthDecl,
   getContainingDataModel: () => getContainingDataModel,
@@ -52,20 +53,20 @@ __export(utils_exports, {
   getModelIdFields: () => getModelIdFields,
   getModelUniqueFields: () => getModelUniqueFields,
   getObjectLiteral: () => getObjectLiteral,
+  getPluginDocuments: () => getPluginDocuments,
   getRecursiveBases: () => getRecursiveBases,
   getStringLiteral: () => getStringLiteral,
   getUniqueFields: () => getUniqueFields,
   hasAttribute: () => hasAttribute,
   isAuthInvocation: () => isAuthInvocation,
   isAuthOrAuthMemberAccess: () => isAuthOrAuthMemberAccess,
+  isBeforeInvocation: () => isBeforeInvocation,
   isCheckInvocation: () => isCheckInvocation,
   isCollectionPredicate: () => isCollectionPredicate,
   isDataFieldReference: () => isDataFieldReference,
   isDelegateModel: () => isDelegateModel,
   isEnumFieldReference: () => isEnumFieldReference,
   isFromStdlib: () => isFromStdlib,
-  isFutureExpr: () => isFutureExpr,
-  isFutureInvocation: () => isFutureInvocation,
   isMemberContainer: () => isMemberContainer,
   isRelationshipField: () => isRelationshipField,
   mapBuiltinTypeToExpressionType: () => mapBuiltinTypeToExpressionType,
@@ -76,13 +77,15 @@ __export(utils_exports, {
   typeAssignable: () => typeAssignable
 });
 module.exports = __toCommonJS(utils_exports);
-var import_common_helpers = require("@zenstackhq/common-helpers");
 var import_langium = require("langium");
 var import_node_fs = __toESM(require("fs"), 1);
-var import_path = __toESM(require("path"), 1);
+var import_node_module = require("module");
+var import_node_path = __toESM(require("path"), 1);
+var import_node_url = require("url");
 
 // src/constants.ts
 var STD_LIB_MODULE_NAME = "stdlib.zmodel";
+var PLUGIN_MODULE_NAME = "plugin.zmodel";
 
 // src/generated/ast.ts
 var langium = __toESM(require("langium"), 1);
@@ -175,6 +178,10 @@ function isObjectExpr(item) {
 }
 __name(isObjectExpr, "isObjectExpr");
 var Plugin = "Plugin";
+function isPlugin(item) {
+  return reflection.isInstance(item, Plugin);
+}
+__name(isPlugin, "isPlugin");
 var PluginField = "PluginField";
 var Procedure = "Procedure";
 var ProcedureParam = "ProcedureParam";
@@ -1039,6 +1046,7 @@ var ZModelAstReflection = class extends langium.AbstractAstReflection {
 var reflection = new ZModelAstReflection();
 
 // src/utils.ts
+var import_meta = {};
 function hasAttribute(decl, name) {
   return !!getAttribute(decl, name);
 }
@@ -1118,10 +1126,6 @@ function isRelationshipField(field) {
   return isDataModel(field.type.reference?.ref);
 }
 __name(isRelationshipField, "isRelationshipField");
-function isFutureExpr(node) {
-  return isInvocationExpr(node) && node.function.ref?.name === "future" && isFromStdlib(node.function.ref);
-}
-__name(isFutureExpr, "isFutureExpr");
 function isDelegateModel(node) {
   return isDataModel(node) && hasAttribute(node, "@@delegate");
 }
@@ -1139,8 +1143,14 @@ function getRecursiveBases(decl, includeDelegate = true, seen = /* @__PURE__ */
     return result;
   }
   seen.add(decl);
-  decl.mixins.forEach((mixin) => {
-    const baseDecl = mixin.ref;
+  const bases = [
+    ...decl.mixins,
+    ...isDataModel(decl) && decl.baseModel ? [
+      decl.baseModel
+    ] : []
+  ];
+  bases.forEach((base) => {
+    const baseDecl = decl.$container.declarations.find((d) => (isTypeDef(d) || isDataModel(d)) && d.name === base.$refText);
     if (baseDecl) {
       if (!includeDelegate && isDelegateModel(baseDecl)) {
         return;
@@ -1263,6 +1273,10 @@ function getArray(expr) {
   return isArrayExpr(expr) || isConfigArrayExpr(expr) ? expr.items : void 0;
 }
 __name(getArray, "getArray");
+function getAttributeArg(attr, name) {
+  return attr.args.find((arg) => arg.$resolvedParam?.name === name)?.value;
+}
+__name(getAttributeArg, "getAttributeArg");
 function getAttributeArgLiteral(attr, name) {
   for (const arg of attr.args) {
     if (arg.$resolvedParam?.name === name) {
@@ -1299,7 +1313,7 @@ function getFieldReference(expr) {
 }
 __name(getFieldReference, "getFieldReference");
 function isCheckInvocation(node) {
-  return isInvocationExpr(node) && node.function.ref?.name === "check" && isFromStdlib(node.function.ref);
+  return isInvocationExpr(node) && node.function.ref?.name === "check";
 }
 __name(isCheckInvocation, "isCheckInvocation");
 function resolveTransitiveImports(documents, model) {
@@ -1349,9 +1363,9 @@ function resolveImportUri(imp) {
     return void 0;
   }
   const doc = import_langium.AstUtils.getDocument(imp);
-  const dir = import_path.default.dirname(doc.uri.fsPath);
+  const dir = import_node_path.default.dirname(doc.uri.fsPath);
   const importPath = imp.path.endsWith(".zmodel") ? imp.path : `${imp.path}.zmodel`;
-  return import_langium.URI.file(import_path.default.resolve(dir, importPath));
+  return import_langium.URI.file(import_node_path.default.resolve(dir, importPath));
 }
 __name(resolveImportUri, "resolveImportUri");
 function getDataModelAndTypeDefs(model, includeIgnored = false) {
@@ -1369,17 +1383,17 @@ function getAllDeclarationsIncludingImports(documents, model) {
 }
 __name(getAllDeclarationsIncludingImports, "getAllDeclarationsIncludingImports");
 function getAuthDecl(decls) {
-  let authModel = decls.find((m) => hasAttribute(m, "@@auth"));
+  let authModel = decls.find((d) => hasAttribute(d, "@@auth"));
   if (!authModel) {
-    authModel = decls.find((m) => m.name === "User");
+    authModel = decls.find((d) => d.name === "User");
   }
   return authModel;
 }
 __name(getAuthDecl, "getAuthDecl");
-function isFutureInvocation(node) {
-  return isInvocationExpr(node) && node.function.ref?.name === "future" && isFromStdlib(node.function.ref);
+function isBeforeInvocation(node) {
+  return isInvocationExpr(node) && node.function.ref?.name === "before";
 }
-__name(isFutureInvocation, "isFutureInvocation");
+__name(isBeforeInvocation, "isBeforeInvocation");
 function isCollectionPredicate(node) {
   return isBinaryExpr(node) && [
     "?",
@@ -1434,12 +1448,14 @@ function getAllFields(decl, includeIgnored = false, seen = /* @__PURE__ */ new S
   seen.add(decl);
   const fields = [];
   for (const mixin of decl.mixins) {
-    (0, import_common_helpers.invariant)(mixin.ref, `Mixin ${mixin.$refText} is not resolved`);
-    fields.push(...getAllFields(mixin.ref, includeIgnored, seen));
+    if (mixin.ref) {
+      fields.push(...getAllFields(mixin.ref, includeIgnored, seen));
+    }
   }
   if (isDataModel(decl) && decl.baseModel) {
-    (0, import_common_helpers.invariant)(decl.baseModel.ref, `Base model ${decl.baseModel.$refText} is not resolved`);
-    fields.push(...getAllFields(decl.baseModel.ref, includeIgnored, seen));
+    if (decl.baseModel.ref) {
+      fields.push(...getAllFields(decl.baseModel.ref, includeIgnored, seen));
+    }
   }
   fields.push(...decl.fields.filter((f) => includeIgnored || !hasAttribute(f, "@ignore")));
   return fields;
@@ -1452,12 +1468,14 @@ function getAllAttributes(decl, seen = /* @__PURE__ */ new Set()) {
   seen.add(decl);
   const attributes = [];
   for (const mixin of decl.mixins) {
-    (0, import_common_helpers.invariant)(mixin.ref, `Mixin ${mixin.$refText} is not resolved`);
-    attributes.push(...getAllAttributes(mixin.ref, seen));
+    if (mixin.ref) {
+      attributes.push(...getAllAttributes(mixin.ref, seen));
+    }
   }
   if (isDataModel(decl) && decl.baseModel) {
-    (0, import_common_helpers.invariant)(decl.baseModel.ref, `Base model ${decl.baseModel.$refText} is not resolved`);
-    attributes.push(...getAllAttributes(decl.baseModel.ref, seen));
+    if (decl.baseModel.ref) {
+      attributes.push(...getAllAttributes(decl.baseModel.ref, seen));
+    }
   }
   attributes.push(...decl.attributes);
   return attributes;
@@ -1472,6 +1490,71 @@ function getDocument(node) {
   return result;
 }
 __name(getDocument, "getDocument");
+function getPluginDocuments(model, schemaPath) {
+  const result = [];
+  for (const decl of model.declarations.filter(isPlugin)) {
+    const providerField = decl.fields.find((f) => f.name === "provider");
+    if (!providerField) {
+      continue;
+    }
+    const provider = getLiteral(providerField.value);
+    if (!provider) {
+      continue;
+    }
+    let pluginModelFile;
+    let providerPath = import_node_path.default.resolve(import_node_path.default.dirname(schemaPath), provider);
+    if (import_node_fs.default.existsSync(providerPath)) {
+      if (import_node_fs.default.statSync(providerPath).isDirectory()) {
+        providerPath = import_node_path.default.join(providerPath, "index.js");
+      }
+      pluginModelFile = import_node_path.default.resolve(import_node_path.default.dirname(providerPath), PLUGIN_MODULE_NAME);
+      if (!import_node_fs.default.existsSync(pluginModelFile)) {
+        pluginModelFile = findUp([
+          PLUGIN_MODULE_NAME
+        ], import_node_path.default.dirname(providerPath));
+      }
+    }
+    if (!pluginModelFile) {
+      if (typeof import_meta.resolve === "function") {
+        try {
+          const resolvedUrl = import_meta.resolve(`${provider}/${PLUGIN_MODULE_NAME}`);
+          pluginModelFile = (0, import_node_url.fileURLToPath)(resolvedUrl);
+        } catch {
+        }
+      }
+    }
+    if (!pluginModelFile) {
+      try {
+        const require2 = (0, import_node_module.createRequire)((0, import_node_url.pathToFileURL)(schemaPath));
+        pluginModelFile = require2.resolve(`${provider}/${PLUGIN_MODULE_NAME}`);
+      } catch {
+      }
+    }
+    if (pluginModelFile && import_node_fs.default.existsSync(pluginModelFile)) {
+      result.push(pluginModelFile);
+    }
+  }
+  return result;
+}
+__name(getPluginDocuments, "getPluginDocuments");
+function findUp(names, cwd = process.cwd(), multiple = false, result = []) {
+  if (!names.some((name) => !!name)) {
+    return void 0;
+  }
+  const target = names.find((name) => import_node_fs.default.existsSync(import_node_path.default.join(cwd, name)));
+  if (multiple === false && target) {
+    return import_node_path.default.join(cwd, target);
+  }
+  if (target) {
+    result.push(import_node_path.default.join(cwd, target));
+  }
+  const up = import_node_path.default.resolve(cwd, "..");
+  if (up === cwd) {
+    return multiple && result.length > 0 ? result : void 0;
+  }
+  return findUp(names, up, multiple, result);
+}
+__name(findUp, "findUp");
 function findRootNode(node) {
   while (node.$container) {
     node = node.$container;
@@ -1490,6 +1573,7 @@ __name(findRootNode, "findRootNode");
   getAllLoadedAndReachableDataModelsAndTypeDefs,
   getAllLoadedDataModelsAndTypeDefs,
   getAttribute,
+  getAttributeArg,
   getAttributeArgLiteral,
   getAuthDecl,
   getContainingDataModel,
@@ -1502,20 +1586,20 @@ __name(findRootNode, "findRootNode");
   getModelIdFields,
   getModelUniqueFields,
   getObjectLiteral,
+  getPluginDocuments,
   getRecursiveBases,
   getStringLiteral,
   getUniqueFields,
   hasAttribute,
   isAuthInvocation,
   isAuthOrAuthMemberAccess,
+  isBeforeInvocation,
   isCheckInvocation,
   isCollectionPredicate,
   isDataFieldReference,
   isDelegateModel,
   isEnumFieldReference,
   isFromStdlib,
-  isFutureExpr,
-  isFutureInvocation,
   isMemberContainer,
   isRelationshipField,
   mapBuiltinTypeToExpressionType,