@zenstackhq/language 3.0.0-beta.1 → 3.0.0-beta.11

package/dist/index.js

@@ -7,12 +7,11 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
-// src/index.ts
-import { isAstNode, URI as URI3 } from "langium";
-import { NodeFileSystem } from "langium/node";
+// src/document.ts
+import { isAstNode, URI as URI4 } from "langium";
 import fs3 from "fs";
-import path3 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import path4 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 
 // src/generated/ast.ts
 import * as langium from "langium";
@@ -1042,8 +1041,11 @@ var ExpressionContext = /* @__PURE__ */ function(ExpressionContext2) {
 }({});
 
 // src/module.ts
-import { inject } from "langium";
+import { DocumentState as DocumentState2, inject, URI as URI3 } from "langium";
 import { createDefaultModule, createDefaultSharedModule } from "langium/lsp";
+import { NodeFileSystem } from "langium/node";
+import path3 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/generated/grammar.ts
 import { loadGrammarFromJson } from "langium";
@@ -5104,15 +5106,12 @@ var ZModelGeneratedModule = {
   parser: {}
 };
 
-// src/validators/attribute-application-validator.ts
-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 { createRequire } from "module";
 import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
 function hasAttribute(decl, name) {
   return !!getAttribute(decl, name);
 }
@@ -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");
 }
@@ -5213,8 +5208,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;
@@ -5354,7 +5355,7 @@ function getFunctionExpressionContext(funcDecl) {
 }
 __name(getFunctionExpressionContext, "getFunctionExpressionContext");
 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) {
@@ -5424,17 +5425,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) && [
     "?",
@@ -5489,12 +5490,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 +5510,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;
@@ -5527,6 +5532,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;
@@ -5536,6 +5606,8 @@ function findRootNode(node) {
 __name(findRootNode, "findRootNode");
 
 // src/validators/attribute-application-validator.ts
+import { AstUtils as AstUtils2 } from "langium";
+import pluralize from "pluralize";
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -5649,6 +5721,7 @@ var AttributeApplicationValidator = class {
       });
     }
   }
+  // TODO: design a way to let plugin register validation
   _checkModelLevelPolicy(attr, accept) {
     const kind = getStringLiteral(attr.args[0]?.value);
     if (!kind) {
@@ -5661,11 +5734,61 @@ var AttributeApplicationValidator = class {
       "create",
       "read",
       "update",
+      "post-update",
       "delete",
       "all"
     ], attr, accept);
-    this.rejectEncryptedFields(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);
+    if (!contextModel) {
+      return;
+    }
+    if (AstUtils2.streamAst(expr).some((node) => {
+      if (!isDataFieldReference(node)) {
+        return false;
+      }
+      if (node.target.ref?.$container !== contextModel) {
+        return false;
+      }
+      const field = node.target.ref;
+      if (!isRelationshipField(field)) {
+        return false;
+      }
+      if (isAuthOrAuthMemberAccess(node)) {
+        return false;
+      }
+      const startNode = isCollectionPredicate(node.$container) && node.$container.left === node ? node.$container : node;
+      const collectionPredicate = AstUtils2.getContainerOfType(startNode.$container, isCollectionPredicate);
+      if (collectionPredicate && isAuthOrAuthMemberAccess(collectionPredicate.left)) {
+        return false;
+      }
+      const relationAttr = field.attributes.find((attr) => attr.decl.ref?.name === "@relation");
+      if (!relationAttr) {
+        return true;
+      }
+      if (!relationAttr.args.some((arg) => arg.name === "fields")) {
+        return true;
+      }
+      return false;
+    })) {
+      accept("error", `non-owned relation fields are not allowed in "create" rules`, {
+        node: expr
+      });
+    }
+  }
+  // TODO: design a way to let plugin register validation
   _checkFieldLevelPolicy(attr, accept) {
     const kind = getStringLiteral(attr.args[0]?.value);
     if (!kind) {
@@ -5680,8 +5803,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
       });
     }
@@ -5693,7 +5816,6 @@ var AttributeApplicationValidator = class {
         });
       }
     }
-    this.rejectEncryptedFields(attr, accept);
   }
   _checkValidate(attr, accept) {
     const condition = attr.args[0]?.value;
@@ -5703,8 +5825,9 @@ var AttributeApplicationValidator = class {
       });
     }
   }
-  _checkUnique(attr, accept) {
+  _checkConstraint(attr, accept) {
     const fields = attr.args[0]?.value;
+    const attrName = attr.decl.ref?.name;
     if (!fields) {
       accept("error", `expects an array of field references`, {
         node: attr.args[0]
@@ -5713,7 +5836,7 @@ var AttributeApplicationValidator = class {
     }
     if (isArrayExpr(fields)) {
       if (fields.items.length === 0) {
-        accept("error", `\`@@unique\` expects at least one field reference`, {
+        accept("error", `\`${attrName}\` expects at least one field reference`, {
           node: fields
         });
         return;
@@ -5732,7 +5855,7 @@ var AttributeApplicationValidator = class {
           return;
         }
         if (item.target.ref.$container !== attr.$container && isDelegateModel(item.target.ref.$container)) {
-          accept("error", `Cannot use fields inherited from a polymorphic base model in \`@@unique\``, {
+          accept("error", `Cannot use fields inherited from a polymorphic base model in \`${attrName}\``, {
             node: item
           });
         }
@@ -5743,15 +5866,6 @@ var AttributeApplicationValidator = class {
       });
     }
   }
-  rejectEncryptedFields(attr, accept) {
-    AstUtils2.streamAllContents(attr).forEach((node) => {
-      if (isDataFieldReference(node) && hasAttribute(node.target.ref, "@encrypted")) {
-        accept("error", `Encrypted fields cannot be used in policy rules`, {
-          node
-        });
-      }
-    });
-  }
   validatePolicyKinds(kind, candidates, attr, accept) {
     const items = kind.split(",").map((x) => x.trim());
     items.forEach((item) => {
@@ -5794,15 +5908,16 @@ _ts_decorate([
   _ts_metadata("design:returntype", void 0)
 ], AttributeApplicationValidator.prototype, "_checkValidate", null);
 _ts_decorate([
-  check("@@unique"),
   check("@@id"),
+  check("@@index"),
+  check("@@unique"),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
     typeof AttributeApplication === "undefined" ? Object : AttributeApplication,
     typeof ValidationAcceptor === "undefined" ? Object : ValidationAcceptor
   ]),
   _ts_metadata("design:returntype", void 0)
-], AttributeApplicationValidator.prototype, "_checkUnique", null);
+], AttributeApplicationValidator.prototype, "_checkConstraint", null);
 function assignableToAttributeParam(arg, param, attr) {
   const argResolvedType = arg.$resolvedType;
   if (!argResolvedType) {
@@ -5812,6 +5927,10 @@ function assignableToAttributeParam(arg, param, attr) {
   let dstIsArray = param.type.array;
   if (dstType === "ContextType") {
     if (isDataField(attr.$container)) {
+      const dstIsTypedJson = hasAttribute(attr.$container, "@json");
+      if (dstIsTypedJson && attr.decl.ref?.name === "@default") {
+        return argResolvedType.decl === "String";
+      }
       dstIsArray = attr.$container.type.array;
     }
   }
@@ -5903,6 +6022,9 @@ function isValidAttributeTarget(attrDecl, targetDecl) {
       case "TypeDefField":
         allowed = allowed || isTypeDef(targetDecl.type.reference?.ref);
         break;
+      case "ListField":
+        allowed = allowed || !isDataModel(targetDecl.type.reference?.ref) && targetDecl.type.array;
+        break;
       default:
         break;
     }
@@ -5929,7 +6051,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
@@ -6300,7 +6422,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,
@@ -6322,7 +6444,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);
       }
     }
@@ -6452,11 +6574,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": {
@@ -6509,23 +6641,25 @@ var ExpressionValidator = class {
             "Any"
           ];
         }
-        if (typeof expr.left.$resolvedType?.decl !== "string" || !supportedShapes.includes(expr.left.$resolvedType.decl)) {
+        const leftResolvedDecl = expr.left.$resolvedType?.decl;
+        const rightResolvedDecl = expr.right.$resolvedType?.decl;
+        if (leftResolvedDecl && (typeof leftResolvedDecl !== "string" || !supportedShapes.includes(leftResolvedDecl))) {
           accept("error", `invalid operand type for "${expr.operator}" operator`, {
             node: expr.left
           });
           return;
         }
-        if (typeof expr.right.$resolvedType?.decl !== "string" || !supportedShapes.includes(expr.right.$resolvedType.decl)) {
+        if (rightResolvedDecl && (typeof rightResolvedDecl !== "string" || !supportedShapes.includes(rightResolvedDecl))) {
           accept("error", `invalid operand type for "${expr.operator}" operator`, {
             node: expr.right
           });
           return;
         }
-        if (expr.left.$resolvedType.decl === "DateTime" && expr.right.$resolvedType.decl !== "DateTime") {
+        if (leftResolvedDecl === "DateTime" && rightResolvedDecl && rightResolvedDecl !== "DateTime") {
           accept("error", "incompatible operand types", {
             node: expr
           });
-        } else if (expr.right.$resolvedType.decl === "DateTime" && expr.left.$resolvedType.decl !== "DateTime") {
+        } else if (rightResolvedDecl === "DateTime" && leftResolvedDecl && leftResolvedDecl !== "DateTime") {
           accept("error", "incompatible operand types", {
             node: expr
           });
@@ -6565,11 +6699,11 @@ var ExpressionValidator = class {
             });
           }
           if (isDataFieldReference(expr.left) && (isThisExpr(expr.right) || isDataFieldReference(expr.right))) {
-            accept("error", "comparison between model-typed fields are not supported", {
+            accept("error", "comparison between models is not supported", {
               node: expr
             });
           } else if (isDataFieldReference(expr.right) && (isThisExpr(expr.left) || isDataFieldReference(expr.left))) {
-            accept("error", "comparison between model-typed fields are not supported", {
+            accept("error", "comparison between models is not supported", {
               node: expr
             });
           }
@@ -6659,41 +6793,39 @@ var FunctionInvocationValidator = class {
     if (!this.validateArgs(funcDecl, expr.args, accept)) {
       return;
     }
-    if (isFromStdlib(funcDecl)) {
-      let curr = expr.$container;
-      let containerAttribute;
-      while (curr) {
-        if (isDataModelAttribute(curr) || isDataFieldAttribute(curr)) {
-          containerAttribute = curr;
-          break;
-        }
-        curr = curr.$container;
+    let curr = expr.$container;
+    let containerAttribute;
+    while (curr) {
+      if (isDataModelAttribute(curr) || isDataFieldAttribute(curr)) {
+        containerAttribute = curr;
+        break;
       }
-      const exprContext = match(containerAttribute?.decl.$refText).with("@default", () => ExpressionContext.DefaultValue).with(P.union("@@allow", "@@deny", "@allow", "@deny"), () => ExpressionContext.AccessPolicy).with("@@validate", () => ExpressionContext.ValidationRule).with("@@index", () => ExpressionContext.Index).otherwise(() => void 0);
-      const funcAllowedContext = getFunctionExpressionContext(funcDecl);
-      if (exprContext && !funcAllowedContext.includes(exprContext)) {
-        accept("error", `function "${funcDecl.name}" is not allowed in the current context: ${exprContext}`, {
-          node: expr
+      curr = curr.$container;
+    }
+    const exprContext = this.getExpressionContext(containerAttribute);
+    const funcAllowedContext = getFunctionExpressionContext(funcDecl);
+    if (exprContext && !funcAllowedContext.includes(exprContext)) {
+      accept("error", `function "${funcDecl.name}" is not allowed in the current context: ${exprContext}`, {
+        node: expr
+      });
+      return;
+    }
+    const allCasing = [
+      "original",
+      "upper",
+      "lower",
+      "capitalize",
+      "uncapitalize"
+    ];
+    if ([
+      "currentModel",
+      "currentOperation"
+    ].includes(funcDecl.name)) {
+      const arg = getLiteral(expr.args[0]?.value);
+      if (arg && !allCasing.includes(arg)) {
+        accept("error", `argument must be one of: ${allCasing.map((c) => '"' + c + '"').join(", ")}`, {
+          node: expr.args[0]
         });
-        return;
-      }
-      const allCasing = [
-        "original",
-        "upper",
-        "lower",
-        "capitalize",
-        "uncapitalize"
-      ];
-      if ([
-        "currentModel",
-        "currentOperation"
-      ].includes(funcDecl.name)) {
-        const arg = getLiteral(expr.args[0]?.value);
-        if (arg && !allCasing.includes(arg)) {
-          accept("error", `argument must be one of: ${allCasing.map((c) => '"' + c + '"').join(", ")}`, {
-            node: expr.args[0]
-          });
-        }
       }
     }
     const checker = invocationCheckers.get(expr.function.$refText);
@@ -6701,6 +6833,18 @@ var FunctionInvocationValidator = class {
       checker.value.call(this, expr, accept);
     }
   }
+  getExpressionContext(containerAttribute) {
+    if (!containerAttribute) {
+      return void 0;
+    }
+    if (this.isValidationAttribute(containerAttribute)) {
+      return ExpressionContext.ValidationRule;
+    }
+    return match(containerAttribute?.decl.$refText).with("@default", () => ExpressionContext.DefaultValue).with(P.union("@@allow", "@@deny", "@allow", "@deny"), () => ExpressionContext.AccessPolicy).with("@@index", () => ExpressionContext.Index).otherwise(() => void 0);
+  }
+  isValidationAttribute(attr) {
+    return !!attr.decl.ref?.attributes.some((attr2) => attr2.decl.$refText === "@@@validation");
+  }
   validateArgs(funcDecl, args, accept) {
     let success = true;
     for (let i = 0; i < funcDecl.params.length; i++) {
@@ -6761,6 +6905,44 @@ var FunctionInvocationValidator = class {
     }
     return true;
   }
+  _checkLength(expr, accept) {
+    const msg = "argument must be a string or list field";
+    const fieldArg = expr.args[0].value;
+    if (!isDataFieldReference(fieldArg)) {
+      accept("error", msg, {
+        node: expr.args[0]
+      });
+      return;
+    }
+    if (isDataModel(fieldArg.$resolvedType?.decl)) {
+      accept("error", msg, {
+        node: expr.args[0]
+      });
+      return;
+    }
+    if (!fieldArg.$resolvedType?.array && fieldArg.$resolvedType?.decl !== "String") {
+      accept("error", msg, {
+        node: expr.args[0]
+      });
+    }
+  }
+  _checkRegex(expr, accept) {
+    const regex = expr.args[1]?.value;
+    if (!isStringLiteral(regex)) {
+      accept("error", "second argument must be a string literal", {
+        node: expr.args[1]
+      });
+      return;
+    }
+    try {
+      new RegExp(regex.value);
+    } catch (e) {
+      accept("error", "invalid regular expression: " + e.message, {
+        node: expr.args[1]
+      });
+    }
+  }
+  // TODO: move this to policy plugin
   _checkCheck(expr, accept) {
     let valid = true;
     const fieldArg = expr.args[0].value;
@@ -6832,6 +7014,24 @@ var FunctionInvocationValidator = class {
     }
   }
 };
+_ts_decorate2([
+  func("length"),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof InvocationExpr === "undefined" ? Object : InvocationExpr,
+    typeof ValidationAcceptor === "undefined" ? Object : ValidationAcceptor
+  ]),
+  _ts_metadata2("design:returntype", void 0)
+], FunctionInvocationValidator.prototype, "_checkLength", null);
+_ts_decorate2([
+  func("regex"),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof InvocationExpr === "undefined" ? Object : InvocationExpr,
+    typeof ValidationAcceptor === "undefined" ? Object : ValidationAcceptor
+  ]),
+  _ts_metadata2("design:returntype", void 0)
+], FunctionInvocationValidator.prototype, "_checkRegex", null);
 _ts_decorate2([
   func("check"),
   _ts_metadata2("design:type", Function),
@@ -6941,49 +7141,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 {
@@ -7005,21 +7222,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) {
@@ -7148,7 +7363,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;
@@ -7161,7 +7380,7 @@ var ZModelLinker = class extends DefaultLinker {
             nullable: true
           };
         }
-      } else if (isFutureExpr(node)) {
+      } else if (isBeforeInvocation(node)) {
         node.$resolvedType = {
           decl: getContainingDataModel(node)
         };
@@ -7225,7 +7444,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) {
@@ -7239,7 +7458,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) {
@@ -7291,13 +7510,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);
     }
@@ -7367,7 +7582,7 @@ var ZModelScopeComputation = class extends DefaultScopeComputation {
   }
   processNode(node, document, scopes) {
     super.processNode(node, document, scopes);
-    if (isDataModel(node)) {
+    if (isDataModel(node) || isTypeDef(node)) {
       const bases = getRecursiveBases(node);
       for (const base of bases) {
         for (const field of base.fields) {
@@ -7438,7 +7653,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;
@@ -7512,10 +7727,10 @@ function getCollectionPredicateContext(node) {
 __name(getCollectionPredicateContext, "getCollectionPredicateContext");
 
 // src/zmodel-workspace-manager.ts
-import { DefaultWorkspaceManager, URI as URI2, UriUtils as UriUtils2 } from "langium";
+import { DefaultWorkspaceManager, URI as URI2 } from "langium";
 import fs2 from "fs";
 import path2 from "path";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 var ZModelWorkspaceManager = class extends DefaultWorkspaceManager {
   static {
     __name(this, "ZModelWorkspaceManager");
@@ -7551,73 +7766,12 @@ var ZModelWorkspaceManager = class extends DefaultWorkspaceManager {
     if (installedStdlibPath) {
       stdLibPath = installedStdlibPath;
     } else {
-      const _dirname = typeof __dirname !== "undefined" ? __dirname : path2.dirname(fileURLToPath(import.meta.url));
+      const _dirname = typeof __dirname !== "undefined" ? __dirname : path2.dirname(fileURLToPath2(import.meta.url));
       stdLibPath = path2.join(_dirname, "../res", STD_LIB_MODULE_NAME);
       console.log(`Using bundled stdlib in extension:`, stdLibPath);
     }
     const stdlib = await this.documentFactory.fromUri(URI2.file(stdLibPath));
     collector(stdlib);
-    const documents = this.langiumDocuments.all;
-    const pluginModels = /* @__PURE__ */ new Set();
-    documents.forEach((doc) => {
-      const parsed = doc.parseResult.value;
-      parsed.declarations.forEach((decl) => {
-        if (isPlugin(decl)) {
-          const providerField = decl.fields.find((f) => f.name === "provider");
-          if (providerField) {
-            const provider = getLiteral(providerField.value);
-            if (provider) {
-              pluginModels.add(provider);
-            }
-          }
-        }
-      });
-    });
-    if (pluginModels.size > 0) {
-      console.log(`Used plugin modules: ${Array.from(pluginModels)}`);
-      const pendingPluginModules = new Set(pluginModels);
-      await Promise.all(folders.map((wf) => [
-        wf,
-        this.getRootFolder(wf)
-      ]).map(async (entry) => this.loadPluginModels(...entry, pendingPluginModules, collector)));
-    }
-  }
-  async loadPluginModels(workspaceFolder, folderPath, pendingPluginModels, collector) {
-    const content = (await this.fileSystemProvider.readDirectory(folderPath)).sort((a, b) => {
-      if (a.isDirectory && b.isDirectory) {
-        const aName = UriUtils2.basename(a.uri);
-        if (aName === "node_modules") {
-          return -1;
-        } else {
-          return 1;
-        }
-      } else {
-        return 0;
-      }
-    });
-    for (const entry of content) {
-      if (entry.isDirectory) {
-        const name = UriUtils2.basename(entry.uri);
-        if (name === "node_modules") {
-          for (const plugin of Array.from(pendingPluginModels)) {
-            const path4 = UriUtils2.joinPath(entry.uri, plugin, PLUGIN_MODULE_NAME);
-            try {
-              await this.fileSystemProvider.readFile(path4);
-              const document = await this.langiumDocuments.getOrCreateDocument(path4);
-              collector(document);
-              console.log(`Adding plugin document from ${path4.path}`);
-              pendingPluginModels.delete(plugin);
-              if (pendingPluginModels.size === 0) {
-                return;
-              }
-            } catch {
-            }
-          }
-        } else {
-          await this.loadPluginModels(workspaceFolder, entry.uri, pendingPluginModels, collector);
-        }
-      }
-    }
   }
 };
 
@@ -7634,10 +7788,11 @@ var ZModelLanguageModule = {
 };
 var ZModelSharedModule = {
   workspace: {
+    DocumentBuilder: /* @__PURE__ */ __name((services) => new ZModelDocumentBuilder(services), "DocumentBuilder"),
     WorkspaceManager: /* @__PURE__ */ __name((services) => new ZModelWorkspaceManager(services), "WorkspaceManager")
   }
 };
-function createZModelLanguageServices(context) {
+function createZModelLanguageServices(context, logToConsole = false) {
   const shared = inject(createDefaultSharedModule(context), ZModelGeneratedSharedModule, ZModelSharedModule);
   const ZModelLanguage = inject(createDefaultModule({
     shared
@@ -7647,30 +7802,41 @@ function createZModelLanguageServices(context) {
   if (!context.connection) {
     shared.workspace.ConfigurationProvider.initialized({});
   }
+  shared.workspace.DocumentBuilder.onBuildPhase(DocumentState2.Parsed, async (documents) => {
+    for (const doc of documents) {
+      if (doc.parseResult.lexerErrors.length > 0 || doc.parseResult.parserErrors.length > 0) {
+        continue;
+      }
+      if (doc.uri.scheme !== "file") {
+        continue;
+      }
+      const schemaPath = fileURLToPath3(doc.uri.toString());
+      const pluginSchemas = getPluginDocuments(doc.parseResult.value, schemaPath);
+      for (const plugin of pluginSchemas) {
+        const pluginDoc = await shared.workspace.LangiumDocuments.getOrCreateDocument(URI3.file(path3.resolve(plugin)));
+        shared.workspace.IndexManager.updateContent(pluginDoc);
+        if (logToConsole) {
+          console.log(`Loaded plugin model: ${plugin}`);
+        }
+      }
+    }
+  });
   return {
     shared,
     ZModelLanguage
   };
 }
 __name(createZModelLanguageServices, "createZModelLanguageServices");
-
-// src/index.ts
-function createZModelServices() {
-  return createZModelLanguageServices(NodeFileSystem);
+function createZModelServices(logToConsole = false) {
+  return createZModelLanguageServices(NodeFileSystem, logToConsole);
 }
 __name(createZModelServices, "createZModelServices");
-var DocumentLoadError = class extends Error {
-  static {
-    __name(this, "DocumentLoadError");
-  }
-  constructor(message) {
-    super(message);
-  }
-};
-async function loadDocument(fileName, pluginModelFiles = []) {
-  const { ZModelLanguage: services } = createZModelServices();
+
+// src/document.ts
+async function loadDocument(fileName, additionalModelFiles = []) {
+  const { ZModelLanguage: services } = createZModelServices(false);
   const extensions = services.LanguageMetaData.fileExtensions;
-  if (!extensions.includes(path3.extname(fileName))) {
+  if (!extensions.includes(path4.extname(fileName))) {
     return {
       success: false,
       errors: [
@@ -7688,23 +7854,27 @@ async function loadDocument(fileName, pluginModelFiles = []) {
       warnings: []
     };
   }
-  const _dirname = typeof __dirname !== "undefined" ? __dirname : path3.dirname(fileURLToPath2(import.meta.url));
-  const stdLib = await services.shared.workspace.LangiumDocuments.getOrCreateDocument(URI3.file(path3.resolve(path3.join(_dirname, "../res", STD_LIB_MODULE_NAME))));
-  const pluginDocs = await Promise.all(pluginModelFiles.map((file) => services.shared.workspace.LangiumDocuments.getOrCreateDocument(URI3.file(path3.resolve(file)))));
+  const _dirname = typeof __dirname !== "undefined" ? __dirname : path4.dirname(fileURLToPath4(import.meta.url));
+  const stdLib = await services.shared.workspace.LangiumDocuments.getOrCreateDocument(URI4.file(path4.resolve(path4.join(_dirname, "../res", STD_LIB_MODULE_NAME))));
   const langiumDocuments = services.shared.workspace.LangiumDocuments;
-  const document = await langiumDocuments.getOrCreateDocument(URI3.file(path3.resolve(fileName)));
+  const document = await langiumDocuments.getOrCreateDocument(URI4.file(path4.resolve(fileName)));
   const importedURIs = await loadImports(document, langiumDocuments);
   const importedDocuments = [];
   for (const uri of importedURIs) {
     importedDocuments.push(await langiumDocuments.getOrCreateDocument(uri));
   }
+  const additionalDocs = await Promise.all(additionalModelFiles.map((file) => services.shared.workspace.LangiumDocuments.getOrCreateDocument(URI4.file(path4.resolve(file)))));
   await services.shared.workspace.DocumentBuilder.build([
     stdLib,
-    ...pluginDocs,
+    ...additionalDocs,
     document,
     ...importedDocuments
   ], {
-    validation: true
+    validation: {
+      stopAfterLexingErrors: true,
+      stopAfterParsingErrors: true,
+      stopAfterLinkingErrors: true
+    }
   });
   const diagnostics = langiumDocuments.all.flatMap((doc) => (doc.diagnostics ?? []).map((diag) => ({
     doc,
@@ -7714,7 +7884,7 @@ async function loadDocument(fileName, pluginModelFiles = []) {
   const warnings = [];
   if (diagnostics.length > 0) {
     for (const { doc, diag } of diagnostics) {
-      const message = `${path3.relative(process.cwd(), doc.uri.fsPath)}:${diag.range.start.line + 1}:${diag.range.start.character + 1} - ${diag.message}`;
+      const message = `${path4.relative(process.cwd(), doc.uri.fsPath)}:${diag.range.start.line + 1}:${diag.range.start.character + 1} - ${diag.message}`;
       if (diag.severity === 1) {
         errors.push(message);
       } else {
@@ -7763,7 +7933,7 @@ async function loadImports(document, documents, uris = /* @__PURE__ */ new Set()
       }
     }
   }
-  return Array.from(uris).filter((x) => uriString != x).map((e) => URI3.parse(e));
+  return Array.from(uris).filter((x) => uriString != x).map((e) => URI4.parse(e));
 }
 __name(loadImports, "loadImports");
 function mergeImportsDeclarations(documents, model) {
@@ -7813,7 +7983,6 @@ function validationAfterImportMerge(model) {
 }
 __name(validationAfterImportMerge, "validationAfterImportMerge");
 export {
-  DocumentLoadError,
   ZModelLanguageMetaData,
   ZModelLanguageModule,
   ZModelSharedModule,