@zenstackhq/language 3.0.0-beta.7 → 3.0.0-beta.8

package/dist/index.js

@@ -5191,10 +5191,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");
 }
@@ -5430,10 +5426,10 @@ function getAuthDecl(decls) {
   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" && isFromStdlib(node.function.ref);
 }
-__name(isFutureInvocation, "isFutureInvocation");
+__name(isBeforeInvocation, "isBeforeInvocation");
 function isCollectionPredicate(node) {
   return isBinaryExpr(node) && [
     "?",
@@ -5665,12 +5661,21 @@ var AttributeApplicationValidator = class {
       "create",
       "read",
       "update",
+      "post-update",
       "delete",
       "all"
     ], attr, accept);
     if ((kind === "create" || kind === "all") && attr.args[1]?.value) {
       this.rejectNonOwnedRelationInExpression(attr.args[1].value, accept);
     }
+    if (kind !== "post-update" && attr.args[1]?.value) {
+      const beforeCall = AstUtils2.streamAst(attr.args[1]?.value).find(isBeforeInvocation);
+      if (beforeCall) {
+        accept("error", `"before()" is only allowed in "post-update" policy rules`, {
+          node: beforeCall
+        });
+      }
+    }
   }
   rejectNonOwnedRelationInExpression(expr, accept) {
     const contextModel = AstUtils2.getContainerOfType(expr, isDataModel);
@@ -5725,8 +5730,8 @@ var AttributeApplicationValidator = class {
       "all"
     ], attr, accept);
     const expr = attr.args[1]?.value;
-    if (expr && AstUtils2.streamAst(expr).some((node) => isFutureExpr(node))) {
-      accept("error", `"future()" is not allowed in field-level policy rules`, {
+    if (expr && AstUtils2.streamAst(expr).some((node) => isBeforeInvocation(node))) {
+      accept("error", `"before()" is not allowed in field-level policy rules`, {
         node: expr
       });
     }
@@ -6487,11 +6492,21 @@ var ExpressionValidator = class {
       }
     }
     switch (expr.$type) {
+      case "MemberAccessExpr":
+        this.validateMemberAccessExpr(expr, accept);
+        break;
       case "BinaryExpr":
         this.validateBinaryExpr(expr, accept);
         break;
     }
   }
+  validateMemberAccessExpr(expr, accept) {
+    if (isBeforeInvocation(expr.operand) && isDataModel(expr.$resolvedType?.decl)) {
+      accept("error", "relation fields cannot be accessed from `before()`", {
+        node: expr
+      });
+    }
+  }
   validateBinaryExpr(expr, accept) {
     switch (expr.operator) {
       case "in": {
@@ -7014,23 +7029,31 @@ var ZModelDocumentBuilder = class extends DefaultDocumentBuilder {
   static {
     __name(this, "ZModelDocumentBuilder");
   }
-  buildDocuments(documents, options, cancelToken) {
-    return super.buildDocuments(documents, {
-      ...options,
-      validation: (
-        // force overriding validation options
-        options.validation === false || options.validation === void 0 ? options.validation : {
-          stopAfterLexingErrors: true,
-          stopAfterParsingErrors: true,
-          stopAfterLinkingErrors: true
-        }
-      )
-    }, cancelToken);
+  constructor(services) {
+    super(services);
+    let validationOptions = this.updateBuildOptions.validation;
+    const stopFlags = {
+      stopAfterLinkingErrors: true,
+      stopAfterLexingErrors: true,
+      stopAfterParsingErrors: true
+    };
+    if (validationOptions === true) {
+      validationOptions = stopFlags;
+    } else if (typeof validationOptions === "object") {
+      validationOptions = {
+        ...validationOptions,
+        ...stopFlags
+      };
+    }
+    this.updateBuildOptions = {
+      ...this.updateBuildOptions,
+      validation: validationOptions
+    };
   }
 };
 
 // src/zmodel-linker.ts
-import { AstUtils as AstUtils6, Cancellation, DefaultLinker, DocumentState, interruptAndCheck, isReference } from "langium";
+import { AstUtils as AstUtils6, Cancellation, DefaultLinker, DocumentState, interruptAndCheck } from "langium";
 import { match as match2 } from "ts-pattern";
 var ZModelLinker = class extends DefaultLinker {
   static {
@@ -7052,21 +7075,19 @@ var ZModelLinker = class extends DefaultLinker {
     }
     document.state = DocumentState.Linked;
   }
-  linkReference(container, property, document, extraScopes) {
-    if (this.resolveFromScopeProviders(container, property, document, extraScopes)) {
+  linkReference(refInfo, document, extraScopes) {
+    const defaultRef = refInfo.reference;
+    if (defaultRef._ref) {
+      return;
+    }
+    if (this.resolveFromScopeProviders(refInfo.reference, document, extraScopes)) {
       return;
     }
-    const reference = container[property];
-    this.doLink({
-      reference,
-      container,
-      property
-    }, document);
+    this.doLink(refInfo, document);
   }
   //#endregion
   //#region Expression type resolving
-  resolveFromScopeProviders(node, property, document, providers) {
-    const reference = node[property];
+  resolveFromScopeProviders(reference, document, providers) {
     for (const provider of providers) {
       const target = provider(reference.$refText);
       if (target) {
@@ -7195,7 +7216,11 @@ var ZModelLinker = class extends DefaultLinker {
     }
   }
   resolveInvocation(node, document, extraScopes) {
-    this.linkReference(node, "function", document, extraScopes);
+    this.linkReference({
+      reference: node.function,
+      container: node,
+      property: "function"
+    }, document, extraScopes);
     node.args.forEach((arg) => this.resolve(arg, document, extraScopes));
     if (node.function.ref) {
       const funcDecl = node.function.ref;
@@ -7208,7 +7233,7 @@ var ZModelLinker = class extends DefaultLinker {
             nullable: true
           };
         }
-      } else if (isFutureExpr(node)) {
+      } else if (isBeforeInvocation(node)) {
         node.$resolvedType = {
           decl: getContainingDataModel(node)
         };
@@ -7272,7 +7297,7 @@ var ZModelLinker = class extends DefaultLinker {
         if (isArrayExpr(node.value)) {
           node.value.items.forEach((item) => {
             if (isReferenceExpr(item)) {
-              const resolved2 = this.resolveFromScopeProviders(item, "target", document, [
+              const resolved2 = this.resolveFromScopeProviders(item.target, document, [
                 scopeProvider
               ]);
               if (resolved2) {
@@ -7286,7 +7311,7 @@ var ZModelLinker = class extends DefaultLinker {
             this.resolveToBuiltinTypeOrDecl(node.value, node.value.items[0].$resolvedType.decl, true);
           }
         } else if (isReferenceExpr(node.value)) {
-          const resolved2 = this.resolveFromScopeProviders(node.value, "target", document, [
+          const resolved2 = this.resolveFromScopeProviders(node.value.target, document, [
             scopeProvider
           ]);
           if (resolved2) {
@@ -7338,13 +7363,9 @@ var ZModelLinker = class extends DefaultLinker {
     this.resolveDefault(node, document, scopes);
   }
   resolveDefault(node, document, extraScopes) {
-    for (const [property, value] of Object.entries(node)) {
-      if (!property.startsWith("$")) {
-        if (isReference(value)) {
-          this.linkReference(node, property, document, extraScopes);
-        }
-      }
-    }
+    AstUtils6.streamReferences(node).forEach((ref) => {
+      this.linkReference(ref, document, extraScopes);
+    });
     for (const child of AstUtils6.streamContents(node)) {
       this.resolve(child, document, extraScopes);
     }
@@ -7485,7 +7506,7 @@ var ZModelScopeProvider = class extends DefaultScopeProvider {
       if (isAuthInvocation(operand)) {
         return this.createScopeForAuth(node, globalScope);
       }
-      if (isFutureInvocation(operand)) {
+      if (isBeforeInvocation(operand)) {
         return this.createScopeForContainingModel(node, globalScope);
       }
       return EMPTY_SCOPE;
@@ -7752,7 +7773,11 @@ async function loadDocument(fileName, pluginModelFiles = []) {
     document,
     ...importedDocuments
   ], {
-    validation: true
+    validation: {
+      stopAfterLexingErrors: true,
+      stopAfterParsingErrors: true,
+      stopAfterLinkingErrors: true
+    }
   });
   const diagnostics = langiumDocuments.all.flatMap((doc) => (doc.diagnostics ?? []).map((diag) => ({
     doc,