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

package/dist/index.d.cts

@@ -21,7 +21,6 @@ declare const ZModelLanguageMetaData: {
 declare class ZModelValidator {
     protected readonly services: ZModelServices;
     constructor(services: ZModelServices);
-    private shouldCheck;
     checkModel(node: Model, accept: ValidationAcceptor): void;
     checkDataSource(node: DataSource, accept: ValidationAcceptor): void;
     checkDataModel(node: DataModel, accept: ValidationAcceptor): void;

package/dist/index.d.ts

@@ -21,7 +21,6 @@ declare const ZModelLanguageMetaData: {
 declare class ZModelValidator {
     protected readonly services: ZModelServices;
     constructor(services: ZModelServices);
-    private shouldCheck;
     checkModel(node: Model, accept: ValidationAcceptor): void;
     checkDataSource(node: DataSource, accept: ValidationAcceptor): void;
     checkDataModel(node: DataModel, accept: ValidationAcceptor): void;

package/dist/index.js

@@ -5109,7 +5109,6 @@ import { AstUtils as AstUtils2 } from "langium";
 import pluralize from "pluralize";
 
 // src/utils.ts
-import { invariant } from "@zenstackhq/common-helpers";
 import { AstUtils, URI } from "langium";
 import fs from "fs";
 import path from "path";
@@ -5192,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");
 }
@@ -5214,7 +5209,7 @@ function getRecursiveBases(decl, includeDelegate = true, seen = /* @__PURE__ */
   }
   seen.add(decl);
   decl.mixins.forEach((mixin) => {
-    const baseDecl = mixin.ref;
+    const baseDecl = decl.$container.declarations.find((d) => isTypeDef(d) && d.name === mixin.$refText);
     if (baseDecl) {
       if (!includeDelegate && isDelegateModel(baseDecl)) {
         return;
@@ -5431,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) && [
     "?",
@@ -5489,12 +5484,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;
@@ -5507,12 +5504,14 @@ 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) {
+      attributes.push(...getAllAttributes(decl.baseModel.ref, seen));
+    }
   }
   attributes.push(...decl.attributes);
   return attributes;
@@ -5662,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);
@@ -5722,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
       });
     }
@@ -5961,7 +5969,7 @@ var AttributeValidator = class {
 };
 
 // src/validators/datamodel-validator.ts
-import { invariant as invariant2 } from "@zenstackhq/common-helpers";
+import { invariant } from "@zenstackhq/common-helpers";
 import { AstUtils as AstUtils3 } from "langium";
 
 // src/validators/common.ts
@@ -6332,7 +6340,7 @@ var DataModelValidator = class {
     if (!model.baseModel) {
       return;
     }
-    invariant2(model.baseModel.ref, "baseModel must be resolved");
+    invariant(model.baseModel.ref, "baseModel must be resolved");
     if (!isDelegateModel(model.baseModel.ref)) {
       accept("error", `Model ${model.baseModel.$refText} cannot be extended because it's not a delegate model`, {
         node: model,
@@ -6354,7 +6362,7 @@ var DataModelValidator = class {
       }
       seen.push(current);
       if (current.baseModel) {
-        invariant2(current.baseModel.ref, "baseModel must be resolved");
+        invariant(current.baseModel.ref, "baseModel must be resolved");
         todo.push(current.baseModel.ref);
       }
     }
@@ -6484,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": {
@@ -6976,49 +6994,66 @@ var ZModelValidator = class {
   constructor(services) {
     this.services = services;
   }
-  shouldCheck(node) {
-    let doc;
-    let currNode = node;
-    while (currNode) {
-      if (currNode.$document) {
-        doc = currNode.$document;
-        break;
-      }
-      currNode = currNode.$container;
-    }
-    return doc?.parseResult.lexerErrors.length === 0 && doc?.parseResult.parserErrors.length === 0;
-  }
   checkModel(node, accept) {
-    this.shouldCheck(node) && new SchemaValidator(this.services.shared.workspace.LangiumDocuments).validate(node, accept);
+    new SchemaValidator(this.services.shared.workspace.LangiumDocuments).validate(node, accept);
   }
   checkDataSource(node, accept) {
-    this.shouldCheck(node) && new DataSourceValidator().validate(node, accept);
+    new DataSourceValidator().validate(node, accept);
   }
   checkDataModel(node, accept) {
-    this.shouldCheck(node) && new DataModelValidator().validate(node, accept);
+    new DataModelValidator().validate(node, accept);
   }
   checkTypeDef(node, accept) {
-    this.shouldCheck(node) && new TypeDefValidator().validate(node, accept);
+    new TypeDefValidator().validate(node, accept);
   }
   checkEnum(node, accept) {
-    this.shouldCheck(node) && new EnumValidator().validate(node, accept);
+    new EnumValidator().validate(node, accept);
   }
   checkAttribute(node, accept) {
-    this.shouldCheck(node) && new AttributeValidator().validate(node, accept);
+    new AttributeValidator().validate(node, accept);
   }
   checkExpression(node, accept) {
-    this.shouldCheck(node) && new ExpressionValidator().validate(node, accept);
+    new ExpressionValidator().validate(node, accept);
   }
   checkFunctionInvocation(node, accept) {
-    this.shouldCheck(node) && new FunctionInvocationValidator().validate(node, accept);
+    new FunctionInvocationValidator().validate(node, accept);
   }
   checkFunctionDecl(node, accept) {
-    this.shouldCheck(node) && new FunctionDeclValidator().validate(node, accept);
+    new FunctionDeclValidator().validate(node, accept);
+  }
+};
+
+// src/zmodel-document-builder.ts
+import { DefaultDocumentBuilder } from "langium";
+var ZModelDocumentBuilder = class extends DefaultDocumentBuilder {
+  static {
+    __name(this, "ZModelDocumentBuilder");
+  }
+  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 {
@@ -7040,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;
     }
-    const reference = container[property];
-    this.doLink({
-      reference,
-      container,
-      property
-    }, document);
+    if (this.resolveFromScopeProviders(refInfo.reference, document, extraScopes)) {
+      return;
+    }
+    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) {
@@ -7183,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;
@@ -7196,7 +7233,7 @@ var ZModelLinker = class extends DefaultLinker {
             nullable: true
           };
         }
-      } else if (isFutureExpr(node)) {
+      } else if (isBeforeInvocation(node)) {
         node.$resolvedType = {
           decl: getContainingDataModel(node)
         };
@@ -7260,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) {
@@ -7274,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) {
@@ -7326,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);
     }
@@ -7473,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;
@@ -7669,6 +7702,7 @@ var ZModelLanguageModule = {
 };
 var ZModelSharedModule = {
   workspace: {
+    DocumentBuilder: /* @__PURE__ */ __name((services) => new ZModelDocumentBuilder(services), "DocumentBuilder"),
     WorkspaceManager: /* @__PURE__ */ __name((services) => new ZModelWorkspaceManager(services), "WorkspaceManager")
   }
 };
@@ -7739,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,