@zenstackhq/language 3.0.0-beta.3 → 3.0.0-beta.31

package/dist/utils.js

@@ -2,13 +2,15 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/utils.ts
-import { invariant } from "@zenstackhq/common-helpers";
 import { AstUtils, URI } from "langium";
 import fs from "fs";
+import { createRequire } from "module";
 import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
 
 // src/constants.ts
 var STD_LIB_MODULE_NAME = "stdlib.zmodel";
+var PLUGIN_MODULE_NAME = "plugin.zmodel";
 
 // src/generated/ast.ts
 import * as langium from "langium";
@@ -101,6 +103,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";
@@ -1044,10 +1050,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");
 }
@@ -1065,8 +1067,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;
@@ -1189,6 +1197,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) {
@@ -1225,7 +1237,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) {
@@ -1295,17 +1307,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) && [
     "?",
@@ -1360,12 +1372,14 @@ function getAllFields(decl, includeIgnored = false, seen = /* @__PURE__ */ new S
   seen.add(decl);
   const fields = [];
   for (const mixin of decl.mixins) {
-    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) {
-    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;
@@ -1378,17 +1392,29 @@ function getAllAttributes(decl, seen = /* @__PURE__ */ new Set()) {
   seen.add(decl);
   const attributes = [];
   for (const mixin of decl.mixins) {
-    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) {
-    invariant(decl.baseModel.ref, `Base model ${decl.baseModel.$refText} is not resolved`);
-    attributes.push(...getAllAttributes(decl.baseModel.ref, seen));
+    if (decl.baseModel.ref) {
+      const attrs = getAllAttributes(decl.baseModel.ref, seen).filter((attr) => !isNonInheritableAttribute(attr));
+      attributes.push(...attrs);
+    }
   }
   attributes.push(...decl.attributes);
   return attributes;
 }
 __name(getAllAttributes, "getAllAttributes");
+function isNonInheritableAttribute(attr) {
+  const attrName = attr.decl.ref?.name ?? attr.decl.$refText;
+  return [
+    "@@map",
+    "@@unique",
+    "@@index"
+  ].includes(attrName);
+}
+__name(isNonInheritableAttribute, "isNonInheritableAttribute");
 function getDocument(node) {
   const rootNode = findRootNode(node);
   const result = rootNode.$document;
@@ -1398,6 +1424,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 = path.resolve(path.dirname(schemaPath), provider);
+    if (fs.existsSync(providerPath)) {
+      if (fs.statSync(providerPath).isDirectory()) {
+        providerPath = path.join(providerPath, "index.js");
+      }
+      pluginModelFile = path.resolve(path.dirname(providerPath), PLUGIN_MODULE_NAME);
+      if (!fs.existsSync(pluginModelFile)) {
+        pluginModelFile = findUp([
+          PLUGIN_MODULE_NAME
+        ], path.dirname(providerPath));
+      }
+    }
+    if (!pluginModelFile) {
+      if (typeof import.meta.resolve === "function") {
+        try {
+          const resolvedUrl = import.meta.resolve(`${provider}/${PLUGIN_MODULE_NAME}`);
+          pluginModelFile = fileURLToPath(resolvedUrl);
+        } catch {
+        }
+      }
+    }
+    if (!pluginModelFile) {
+      try {
+        const require2 = createRequire(pathToFileURL(schemaPath));
+        pluginModelFile = require2.resolve(`${provider}/${PLUGIN_MODULE_NAME}`);
+      } catch {
+      }
+    }
+    if (pluginModelFile && fs.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) => fs.existsSync(path.join(cwd, name)));
+  if (multiple === false && target) {
+    return path.join(cwd, target);
+  }
+  if (target) {
+    result.push(path.join(cwd, target));
+  }
+  const up = path.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;
@@ -1415,6 +1506,7 @@ export {
   getAllLoadedAndReachableDataModelsAndTypeDefs,
   getAllLoadedDataModelsAndTypeDefs,
   getAttribute,
+  getAttributeArg,
   getAttributeArgLiteral,
   getAuthDecl,
   getContainingDataModel,
@@ -1427,20 +1519,20 @@ export {
   getModelIdFields,
   getModelUniqueFields,
   getObjectLiteral,
+  getPluginDocuments,
   getRecursiveBases,
   getStringLiteral,
   getUniqueFields,
   hasAttribute,
   isAuthInvocation,
   isAuthOrAuthMemberAccess,
+  isBeforeInvocation,
   isCheckInvocation,
   isCollectionPredicate,
   isDataFieldReference,
   isDelegateModel,
   isEnumFieldReference,
   isFromStdlib,
-  isFutureExpr,
-  isFutureInvocation,
   isMemberContainer,
   isRelationshipField,
   mapBuiltinTypeToExpressionType,